// $ANTLR 3.1.2 /home/ravn/Workspace/pascal4j/src/pascal.g 2009-07-05 23:48:35

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;


import org.antlr.runtime.tree.*;

public class pascalParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "BLOCK", "IDLIST", "FUNC_CALL", "PROC_CALL", "SCALARTYPE", "TYPELIST", "VARIANT_TAG", "VARIANT_TAG_NO_ID", "VARIANT_CASE", "CONSTLIST", "FIELDLIST", "ARGDECLS", "VARDECL", "ARGDECL", "ARGLIST", "TYPEDECL", "FIELD", "DWIEKROPKI", "KROPKA", "PROGRAM", "LNAWIAS", "PNAWIAS", "SREDNIK", "IDENT", "LABEL", "PRZECINEK", "CONST", "ROWNOSC", "NUM_INT", "NUM_REAL", "PLUS", "MINUS", "STRING_LITERAL", "TYPE", "CHAR", "BOOLEAN", "INTEGER", "REAL", "STRING", "PACKED", "ARRAY", "LNAWIASKWADRATOWY", "PNAWIASKWADRATOWY", "OF", "LNAWIAS2", "PNAWIAS2", "RECORD", "END", "DWUKROPEK", "CASE", "WSKAZNIK", "VAR", "PROCEDURE", "FUNCTION", "PRZYPISANIE", "NIEROWNOSC", "MNIEJSZY", "MNIEJSZYLUBROWNY", "WIEKSZYLUBROWNY", "WIEKSZY", "IN", "OR", "GWIAZDKA", "SLASH", "DIV", "MOD", "AND", "NOT", "NIL", "GOTO", "BEGIN", "IF", "THEN", "ELSE", "WHILE", "DO", "REPEAT", "UNTIL", "FOR", "TO", "DOWNTO", "WITH", "FILE", "AT", "LNAWIASKLAMROWY", "PNAWIASKLAMROWY", "WS", "KOMENTARZ_1", "KOMENTARZ_2", "EXPONENT"
    };
    public static final int FUNCTION=57;
    public static final int EXPONENT=93;
    public static final int WSKAZNIK=54;
    public static final int WHILE=78;
    public static final int MOD=69;
    public static final int CONST=30;
    public static final int KOMENTARZ_2=92;
    public static final int MNIEJSZYLUBROWNY=61;
    public static final int CASE=53;
    public static final int KOMENTARZ_1=91;
    public static final int CHAR=38;
    public static final int DO=79;
    public static final int ARGLIST=18;
    public static final int LNAWIASKWADRATOWY=45;
    public static final int NOT=71;
    public static final int FIELDLIST=14;
    public static final int EOF=-1;
    public static final int TYPE=37;
    public static final int FUNC_CALL=6;
    public static final int SREDNIK=26;
    public static final int STRING_LITERAL=36;
    public static final int DOWNTO=84;
    public static final int VARIANT_CASE=12;
    public static final int ARGDECLS=15;
    public static final int NUM_REAL=33;
    public static final int PRZECINEK=29;
    public static final int PNAWIAS=25;
    public static final int TYPELIST=9;
    public static final int BEGIN=74;
    public static final int LNAWIASKLAMROWY=88;
    public static final int VAR=55;
    public static final int GOTO=73;
    public static final int ARRAY=44;
    public static final int ROWNOSC=31;
    public static final int RECORD=50;
    public static final int DWIEKROPKI=21;
    public static final int ELSE=77;
    public static final int SCALARTYPE=8;
    public static final int OF=47;
    public static final int FILE=86;
    public static final int ARGDECL=17;
    public static final int REAL=41;
    public static final int PNAWIASKWADRATOWY=46;
    public static final int PACKED=43;
    public static final int WS=90;
    public static final int NIL=72;
    public static final int UNTIL=81;
    public static final int NUM_INT=32;
    public static final int OR=65;
    public static final int IDLIST=5;
    public static final int LNAWIAS=24;
    public static final int FIELD=20;
    public static final int REPEAT=80;
    public static final int GWIAZDKA=66;
    public static final int END=51;
    public static final int MNIEJSZY=60;
    public static final int WIEKSZYLUBROWNY=62;
    public static final int LNAWIAS2=48;
    public static final int KROPKA=22;
    public static final int PROC_CALL=7;
    public static final int VARIANT_TAG_NO_ID=11;
    public static final int FOR=82;
    public static final int VARDECL=16;
    public static final int AND=70;
    public static final int PNAWIASKLAMROWY=89;
    public static final int IF=75;
    public static final int AT=87;
    public static final int BOOLEAN=39;
    public static final int NIEROWNOSC=59;
    public static final int SLASH=67;
    public static final int IN=64;
    public static final int THEN=76;
    public static final int WIEKSZY=63;
    public static final int IDENT=27;
    public static final int PLUS=34;
    public static final int TYPEDECL=19;
    public static final int CONSTLIST=13;
    public static final int WITH=85;
    public static final int INTEGER=40;
    public static final int TO=83;
    public static final int DWUKROPEK=52;
    public static final int MINUS=35;
    public static final int PROCEDURE=56;
    public static final int VARIANT_TAG=10;
    public static final int LABEL=28;
    public static final int BLOCK=4;
    public static final int PROGRAM=23;
    public static final int PRZYPISANIE=58;
    public static final int DIV=68;
    public static final int PNAWIAS2=49;
    public static final int STRING=42;

    // delegates
    // delegators


        public pascalParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public pascalParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return pascalParser.tokenNames; }
    public String getGrammarFileName() { return "/home/ravn/Workspace/pascal4j/src/pascal.g"; }


    public static class program_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "program"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:28:1: program : naglowek_programu blok KROPKA ;
    public final pascalParser.program_return program() throws RecognitionException {
        pascalParser.program_return retval = new pascalParser.program_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token KROPKA3=null;
        pascalParser.naglowek_programu_return naglowek_programu1 = null;

        pascalParser.blok_return blok2 = null;


        Object KROPKA3_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:29:5: ( naglowek_programu blok KROPKA )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:29:7: naglowek_programu blok KROPKA
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_naglowek_programu_in_program104);
            naglowek_programu1=naglowek_programu();

            state._fsp--;

            adaptor.addChild(root_0, naglowek_programu1.getTree());
            pushFollow(FOLLOW_blok_in_program112);
            blok2=blok();

            state._fsp--;

            adaptor.addChild(root_0, blok2.getTree());
            KROPKA3=(Token)match(input,KROPKA,FOLLOW_KROPKA_in_program120); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "program"

    public static class naglowek_programu_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "naglowek_programu"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:34:1: naglowek_programu : PROGRAM identyfikator ( LNAWIAS lista_identyfikatorow PNAWIAS )? SREDNIK -> ^( PROGRAM identyfikator ( lista_identyfikatorow )? ) ;
    public final pascalParser.naglowek_programu_return naglowek_programu() throws RecognitionException {
        pascalParser.naglowek_programu_return retval = new pascalParser.naglowek_programu_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PROGRAM4=null;
        Token LNAWIAS6=null;
        Token PNAWIAS8=null;
        Token SREDNIK9=null;
        pascalParser.identyfikator_return identyfikator5 = null;

        pascalParser.lista_identyfikatorow_return lista_identyfikatorow7 = null;


        Object PROGRAM4_tree=null;
        Object LNAWIAS6_tree=null;
        Object PNAWIAS8_tree=null;
        Object SREDNIK9_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleTokenStream stream_PROGRAM=new RewriteRuleTokenStream(adaptor,"token PROGRAM");
        RewriteRuleTokenStream stream_LNAWIAS=new RewriteRuleTokenStream(adaptor,"token LNAWIAS");
        RewriteRuleTokenStream stream_PNAWIAS=new RewriteRuleTokenStream(adaptor,"token PNAWIAS");
        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        RewriteRuleSubtreeStream stream_lista_identyfikatorow=new RewriteRuleSubtreeStream(adaptor,"rule lista_identyfikatorow");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:35:5: ( PROGRAM identyfikator ( LNAWIAS lista_identyfikatorow PNAWIAS )? SREDNIK -> ^( PROGRAM identyfikator ( lista_identyfikatorow )? ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:35:7: PROGRAM identyfikator ( LNAWIAS lista_identyfikatorow PNAWIAS )? SREDNIK
            {
            PROGRAM4=(Token)match(input,PROGRAM,FOLLOW_PROGRAM_in_naglowek_programu138);  
            stream_PROGRAM.add(PROGRAM4);

            pushFollow(FOLLOW_identyfikator_in_naglowek_programu140);
            identyfikator5=identyfikator();

            state._fsp--;

            stream_identyfikator.add(identyfikator5.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:35:29: ( LNAWIAS lista_identyfikatorow PNAWIAS )?
            int alt1=2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0==LNAWIAS) ) {
                alt1=1;
            }
            switch (alt1) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:35:30: LNAWIAS lista_identyfikatorow PNAWIAS
                    {
                    LNAWIAS6=(Token)match(input,LNAWIAS,FOLLOW_LNAWIAS_in_naglowek_programu143);  
                    stream_LNAWIAS.add(LNAWIAS6);

                    pushFollow(FOLLOW_lista_identyfikatorow_in_naglowek_programu145);
                    lista_identyfikatorow7=lista_identyfikatorow();

                    state._fsp--;

                    stream_lista_identyfikatorow.add(lista_identyfikatorow7.getTree());
                    PNAWIAS8=(Token)match(input,PNAWIAS,FOLLOW_PNAWIAS_in_naglowek_programu147);  
                    stream_PNAWIAS.add(PNAWIAS8);


                    }
                    break;

            }

            SREDNIK9=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_naglowek_programu151);  
            stream_SREDNIK.add(SREDNIK9);



            // AST REWRITE
            // elements: identyfikator, lista_identyfikatorow, PROGRAM
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 35:78: -> ^( PROGRAM identyfikator ( lista_identyfikatorow )? )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:35:81: ^( PROGRAM identyfikator ( lista_identyfikatorow )? )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_PROGRAM.nextNode(), root_1);

                adaptor.addChild(root_1, stream_identyfikator.nextTree());
                // /home/ravn/Workspace/pascal4j/src/pascal.g:35:105: ( lista_identyfikatorow )?
                if ( stream_lista_identyfikatorow.hasNext() ) {
                    adaptor.addChild(root_1, stream_lista_identyfikatorow.nextTree());

                }
                stream_lista_identyfikatorow.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "naglowek_programu"

    public static class identyfikator_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "identyfikator"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:38:1: identyfikator : IDENT ;
    public final pascalParser.identyfikator_return identyfikator() throws RecognitionException {
        pascalParser.identyfikator_return retval = new pascalParser.identyfikator_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token IDENT10=null;

        Object IDENT10_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:39:5: ( IDENT )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:39:7: IDENT
            {
            root_0 = (Object)adaptor.nil();

            IDENT10=(Token)match(input,IDENT,FOLLOW_IDENT_in_identyfikator179); 
            IDENT10_tree = (Object)adaptor.create(IDENT10);
            adaptor.addChild(root_0, IDENT10_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "identyfikator"

    public static class blok_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "blok"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:42:1: blok : ( czesc_deklarujaca_etykiety | czesc_definiujaca_stale | czesc_definiujaca_typy | czesc_deklarujaca_zmienne | czesc_deklarujaca_procedury_i_funkcje )* instrukcja_zlozona ;
    public final pascalParser.blok_return blok() throws RecognitionException {
        pascalParser.blok_return retval = new pascalParser.blok_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.czesc_deklarujaca_etykiety_return czesc_deklarujaca_etykiety11 = null;

        pascalParser.czesc_definiujaca_stale_return czesc_definiujaca_stale12 = null;

        pascalParser.czesc_definiujaca_typy_return czesc_definiujaca_typy13 = null;

        pascalParser.czesc_deklarujaca_zmienne_return czesc_deklarujaca_zmienne14 = null;

        pascalParser.czesc_deklarujaca_procedury_i_funkcje_return czesc_deklarujaca_procedury_i_funkcje15 = null;

        pascalParser.instrukcja_zlozona_return instrukcja_zlozona16 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:43:5: ( ( czesc_deklarujaca_etykiety | czesc_definiujaca_stale | czesc_definiujaca_typy | czesc_deklarujaca_zmienne | czesc_deklarujaca_procedury_i_funkcje )* instrukcja_zlozona )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:43:7: ( czesc_deklarujaca_etykiety | czesc_definiujaca_stale | czesc_definiujaca_typy | czesc_deklarujaca_zmienne | czesc_deklarujaca_procedury_i_funkcje )* instrukcja_zlozona
            {
            root_0 = (Object)adaptor.nil();

            // /home/ravn/Workspace/pascal4j/src/pascal.g:43:7: ( czesc_deklarujaca_etykiety | czesc_definiujaca_stale | czesc_definiujaca_typy | czesc_deklarujaca_zmienne | czesc_deklarujaca_procedury_i_funkcje )*
            loop2:
            do {
                int alt2=6;
                switch ( input.LA(1) ) {
                case LABEL:
                    {
                    alt2=1;
                    }
                    break;
                case CONST:
                    {
                    alt2=2;
                    }
                    break;
                case TYPE:
                    {
                    alt2=3;
                    }
                    break;
                case VAR:
                    {
                    alt2=4;
                    }
                    break;
                case PROCEDURE:
                case FUNCTION:
                    {
                    alt2=5;
                    }
                    break;

                }

                switch (alt2) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:43:9: czesc_deklarujaca_etykiety
            	    {
            	    pushFollow(FOLLOW_czesc_deklarujaca_etykiety_in_blok198);
            	    czesc_deklarujaca_etykiety11=czesc_deklarujaca_etykiety();

            	    state._fsp--;

            	    adaptor.addChild(root_0, czesc_deklarujaca_etykiety11.getTree());

            	    }
            	    break;
            	case 2 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:44:9: czesc_definiujaca_stale
            	    {
            	    pushFollow(FOLLOW_czesc_definiujaca_stale_in_blok208);
            	    czesc_definiujaca_stale12=czesc_definiujaca_stale();

            	    state._fsp--;

            	    adaptor.addChild(root_0, czesc_definiujaca_stale12.getTree());

            	    }
            	    break;
            	case 3 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:45:9: czesc_definiujaca_typy
            	    {
            	    pushFollow(FOLLOW_czesc_definiujaca_typy_in_blok218);
            	    czesc_definiujaca_typy13=czesc_definiujaca_typy();

            	    state._fsp--;

            	    adaptor.addChild(root_0, czesc_definiujaca_typy13.getTree());

            	    }
            	    break;
            	case 4 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:46:9: czesc_deklarujaca_zmienne
            	    {
            	    pushFollow(FOLLOW_czesc_deklarujaca_zmienne_in_blok228);
            	    czesc_deklarujaca_zmienne14=czesc_deklarujaca_zmienne();

            	    state._fsp--;

            	    adaptor.addChild(root_0, czesc_deklarujaca_zmienne14.getTree());

            	    }
            	    break;
            	case 5 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:47:9: czesc_deklarujaca_procedury_i_funkcje
            	    {
            	    pushFollow(FOLLOW_czesc_deklarujaca_procedury_i_funkcje_in_blok238);
            	    czesc_deklarujaca_procedury_i_funkcje15=czesc_deklarujaca_procedury_i_funkcje();

            	    state._fsp--;

            	    adaptor.addChild(root_0, czesc_deklarujaca_procedury_i_funkcje15.getTree());

            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);

            pushFollow(FOLLOW_instrukcja_zlozona_in_blok255);
            instrukcja_zlozona16=instrukcja_zlozona();

            state._fsp--;

            adaptor.addChild(root_0, instrukcja_zlozona16.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "blok"

    public static class czesc_deklarujaca_etykiety_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "czesc_deklarujaca_etykiety"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:52:1: czesc_deklarujaca_etykiety : LABEL etykieta ( PRZECINEK etykieta )* SREDNIK -> ^( LABEL ( etykieta )+ ) ;
    public final pascalParser.czesc_deklarujaca_etykiety_return czesc_deklarujaca_etykiety() throws RecognitionException {
        pascalParser.czesc_deklarujaca_etykiety_return retval = new pascalParser.czesc_deklarujaca_etykiety_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token LABEL17=null;
        Token PRZECINEK19=null;
        Token SREDNIK21=null;
        pascalParser.etykieta_return etykieta18 = null;

        pascalParser.etykieta_return etykieta20 = null;


        Object LABEL17_tree=null;
        Object PRZECINEK19_tree=null;
        Object SREDNIK21_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleTokenStream stream_LABEL=new RewriteRuleTokenStream(adaptor,"token LABEL");
        RewriteRuleTokenStream stream_PRZECINEK=new RewriteRuleTokenStream(adaptor,"token PRZECINEK");
        RewriteRuleSubtreeStream stream_etykieta=new RewriteRuleSubtreeStream(adaptor,"rule etykieta");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:53:5: ( LABEL etykieta ( PRZECINEK etykieta )* SREDNIK -> ^( LABEL ( etykieta )+ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:53:7: LABEL etykieta ( PRZECINEK etykieta )* SREDNIK
            {
            LABEL17=(Token)match(input,LABEL,FOLLOW_LABEL_in_czesc_deklarujaca_etykiety272);  
            stream_LABEL.add(LABEL17);

            pushFollow(FOLLOW_etykieta_in_czesc_deklarujaca_etykiety274);
            etykieta18=etykieta();

            state._fsp--;

            stream_etykieta.add(etykieta18.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:53:22: ( PRZECINEK etykieta )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( (LA3_0==PRZECINEK) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:53:24: PRZECINEK etykieta
            	    {
            	    PRZECINEK19=(Token)match(input,PRZECINEK,FOLLOW_PRZECINEK_in_czesc_deklarujaca_etykiety278);  
            	    stream_PRZECINEK.add(PRZECINEK19);

            	    pushFollow(FOLLOW_etykieta_in_czesc_deklarujaca_etykiety280);
            	    etykieta20=etykieta();

            	    state._fsp--;

            	    stream_etykieta.add(etykieta20.getTree());

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);

            SREDNIK21=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_deklarujaca_etykiety285);  
            stream_SREDNIK.add(SREDNIK21);



            // AST REWRITE
            // elements: etykieta, LABEL
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 53:54: -> ^( LABEL ( etykieta )+ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:53:57: ^( LABEL ( etykieta )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_LABEL.nextNode(), root_1);

                if ( !(stream_etykieta.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_etykieta.hasNext() ) {
                    adaptor.addChild(root_1, stream_etykieta.nextTree());

                }
                stream_etykieta.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "czesc_deklarujaca_etykiety"

    public static class etykieta_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "etykieta"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:56:1: etykieta : liczba_calkowita_bez_znaku ;
    public final pascalParser.etykieta_return etykieta() throws RecognitionException {
        pascalParser.etykieta_return retval = new pascalParser.etykieta_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.liczba_calkowita_bez_znaku_return liczba_calkowita_bez_znaku22 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:57:5: ( liczba_calkowita_bez_znaku )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:57:7: liczba_calkowita_bez_znaku
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_liczba_calkowita_bez_znaku_in_etykieta311);
            liczba_calkowita_bez_znaku22=liczba_calkowita_bez_znaku();

            state._fsp--;

            adaptor.addChild(root_0, liczba_calkowita_bez_znaku22.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "etykieta"

    public static class czesc_definiujaca_stale_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "czesc_definiujaca_stale"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:60:1: czesc_definiujaca_stale : CONST definicja_stalej ( SREDNIK definicja_stalej )* SREDNIK -> ^( CONST ( definicja_stalej )+ ) ;
    public final pascalParser.czesc_definiujaca_stale_return czesc_definiujaca_stale() throws RecognitionException {
        pascalParser.czesc_definiujaca_stale_return retval = new pascalParser.czesc_definiujaca_stale_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token CONST23=null;
        Token SREDNIK25=null;
        Token SREDNIK27=null;
        pascalParser.definicja_stalej_return definicja_stalej24 = null;

        pascalParser.definicja_stalej_return definicja_stalej26 = null;


        Object CONST23_tree=null;
        Object SREDNIK25_tree=null;
        Object SREDNIK27_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleTokenStream stream_CONST=new RewriteRuleTokenStream(adaptor,"token CONST");
        RewriteRuleSubtreeStream stream_definicja_stalej=new RewriteRuleSubtreeStream(adaptor,"rule definicja_stalej");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:61:5: ( CONST definicja_stalej ( SREDNIK definicja_stalej )* SREDNIK -> ^( CONST ( definicja_stalej )+ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:61:7: CONST definicja_stalej ( SREDNIK definicja_stalej )* SREDNIK
            {
            CONST23=(Token)match(input,CONST,FOLLOW_CONST_in_czesc_definiujaca_stale328);  
            stream_CONST.add(CONST23);

            pushFollow(FOLLOW_definicja_stalej_in_czesc_definiujaca_stale330);
            definicja_stalej24=definicja_stalej();

            state._fsp--;

            stream_definicja_stalej.add(definicja_stalej24.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:61:30: ( SREDNIK definicja_stalej )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0==SREDNIK) ) {
                    int LA4_1 = input.LA(2);

                    if ( (LA4_1==IDENT) ) {
                        alt4=1;
                    }


                }


                switch (alt4) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:61:32: SREDNIK definicja_stalej
            	    {
            	    SREDNIK25=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_definiujaca_stale334);  
            	    stream_SREDNIK.add(SREDNIK25);

            	    pushFollow(FOLLOW_definicja_stalej_in_czesc_definiujaca_stale336);
            	    definicja_stalej26=definicja_stalej();

            	    state._fsp--;

            	    stream_definicja_stalej.add(definicja_stalej26.getTree());

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);

            SREDNIK27=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_definiujaca_stale341);  
            stream_SREDNIK.add(SREDNIK27);



            // AST REWRITE
            // elements: definicja_stalej, CONST
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 61:68: -> ^( CONST ( definicja_stalej )+ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:61:71: ^( CONST ( definicja_stalej )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_CONST.nextNode(), root_1);

                if ( !(stream_definicja_stalej.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_definicja_stalej.hasNext() ) {
                    adaptor.addChild(root_1, stream_definicja_stalej.nextTree());

                }
                stream_definicja_stalej.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "czesc_definiujaca_stale"

    public static class definicja_stalej_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "definicja_stalej"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:64:1: definicja_stalej : identyfikator ROWNOSC stala -> ^( ROWNOSC identyfikator stala ) ;
    public final pascalParser.definicja_stalej_return definicja_stalej() throws RecognitionException {
        pascalParser.definicja_stalej_return retval = new pascalParser.definicja_stalej_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token ROWNOSC29=null;
        pascalParser.identyfikator_return identyfikator28 = null;

        pascalParser.stala_return stala30 = null;


        Object ROWNOSC29_tree=null;
        RewriteRuleTokenStream stream_ROWNOSC=new RewriteRuleTokenStream(adaptor,"token ROWNOSC");
        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        RewriteRuleSubtreeStream stream_stala=new RewriteRuleSubtreeStream(adaptor,"rule stala");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:65:5: ( identyfikator ROWNOSC stala -> ^( ROWNOSC identyfikator stala ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:65:7: identyfikator ROWNOSC stala
            {
            pushFollow(FOLLOW_identyfikator_in_definicja_stalej367);
            identyfikator28=identyfikator();

            state._fsp--;

            stream_identyfikator.add(identyfikator28.getTree());
            ROWNOSC29=(Token)match(input,ROWNOSC,FOLLOW_ROWNOSC_in_definicja_stalej369);  
            stream_ROWNOSC.add(ROWNOSC29);

            pushFollow(FOLLOW_stala_in_definicja_stalej371);
            stala30=stala();

            state._fsp--;

            stream_stala.add(stala30.getTree());


            // AST REWRITE
            // elements: identyfikator, stala, ROWNOSC
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 65:35: -> ^( ROWNOSC identyfikator stala )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:65:38: ^( ROWNOSC identyfikator stala )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_ROWNOSC.nextNode(), root_1);

                adaptor.addChild(root_1, stream_identyfikator.nextTree());
                adaptor.addChild(root_1, stream_stala.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "definicja_stalej"

    public static class stala_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "stala"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:68:1: stala : ( liczba_bez_znaku | znak liczba_bez_znaku -> ^( znak liczba_bez_znaku ) | identyfikator | znak identyfikator -> ^( znak identyfikator ) | napis );
    public final pascalParser.stala_return stala() throws RecognitionException {
        pascalParser.stala_return retval = new pascalParser.stala_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.liczba_bez_znaku_return liczba_bez_znaku31 = null;

        pascalParser.znak_return znak32 = null;

        pascalParser.liczba_bez_znaku_return liczba_bez_znaku33 = null;

        pascalParser.identyfikator_return identyfikator34 = null;

        pascalParser.znak_return znak35 = null;

        pascalParser.identyfikator_return identyfikator36 = null;

        pascalParser.napis_return napis37 = null;


        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        RewriteRuleSubtreeStream stream_znak=new RewriteRuleSubtreeStream(adaptor,"rule znak");
        RewriteRuleSubtreeStream stream_liczba_bez_znaku=new RewriteRuleSubtreeStream(adaptor,"rule liczba_bez_znaku");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:69:5: ( liczba_bez_znaku | znak liczba_bez_znaku -> ^( znak liczba_bez_znaku ) | identyfikator | znak identyfikator -> ^( znak identyfikator ) | napis )
            int alt5=5;
            switch ( input.LA(1) ) {
            case NUM_INT:
            case NUM_REAL:
                {
                alt5=1;
                }
                break;
            case PLUS:
            case MINUS:
                {
                int LA5_2 = input.LA(2);

                if ( ((LA5_2>=NUM_INT && LA5_2<=NUM_REAL)) ) {
                    alt5=2;
                }
                else if ( (LA5_2==IDENT) ) {
                    alt5=4;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 5, 2, input);

                    throw nvae;
                }
                }
                break;
            case IDENT:
                {
                alt5=3;
                }
                break;
            case STRING_LITERAL:
                {
                alt5=5;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }

            switch (alt5) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:69:7: liczba_bez_znaku
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_liczba_bez_znaku_in_stala398);
                    liczba_bez_znaku31=liczba_bez_znaku();

                    state._fsp--;

                    adaptor.addChild(root_0, liczba_bez_znaku31.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:70:7: znak liczba_bez_znaku
                    {
                    pushFollow(FOLLOW_znak_in_stala406);
                    znak32=znak();

                    state._fsp--;

                    stream_znak.add(znak32.getTree());
                    pushFollow(FOLLOW_liczba_bez_znaku_in_stala408);
                    liczba_bez_znaku33=liczba_bez_znaku();

                    state._fsp--;

                    stream_liczba_bez_znaku.add(liczba_bez_znaku33.getTree());


                    // AST REWRITE
                    // elements: liczba_bez_znaku, znak
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 70:29: -> ^( znak liczba_bez_znaku )
                    {
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:70:32: ^( znak liczba_bez_znaku )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_znak.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_liczba_bez_znaku.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 3 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:71:7: identyfikator
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_identyfikator_in_stala424);
                    identyfikator34=identyfikator();

                    state._fsp--;

                    adaptor.addChild(root_0, identyfikator34.getTree());

                    }
                    break;
                case 4 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:72:7: znak identyfikator
                    {
                    pushFollow(FOLLOW_znak_in_stala432);
                    znak35=znak();

                    state._fsp--;

                    stream_znak.add(znak35.getTree());
                    pushFollow(FOLLOW_identyfikator_in_stala434);
                    identyfikator36=identyfikator();

                    state._fsp--;

                    stream_identyfikator.add(identyfikator36.getTree());


                    // AST REWRITE
                    // elements: znak, identyfikator
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 72:26: -> ^( znak identyfikator )
                    {
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:72:29: ^( znak identyfikator )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_znak.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_identyfikator.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 5 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:73:7: napis
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_napis_in_stala450);
                    napis37=napis();

                    state._fsp--;

                    adaptor.addChild(root_0, napis37.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "stala"

    public static class liczba_bez_znaku_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "liczba_bez_znaku"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:76:1: liczba_bez_znaku : ( liczba_calkowita_bez_znaku | liczba_rzeczywista_bez_znaku );
    public final pascalParser.liczba_bez_znaku_return liczba_bez_znaku() throws RecognitionException {
        pascalParser.liczba_bez_znaku_return retval = new pascalParser.liczba_bez_znaku_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.liczba_calkowita_bez_znaku_return liczba_calkowita_bez_znaku38 = null;

        pascalParser.liczba_rzeczywista_bez_znaku_return liczba_rzeczywista_bez_znaku39 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:77:5: ( liczba_calkowita_bez_znaku | liczba_rzeczywista_bez_znaku )
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==NUM_INT) ) {
                alt6=1;
            }
            else if ( (LA6_0==NUM_REAL) ) {
                alt6=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;
            }
            switch (alt6) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:77:7: liczba_calkowita_bez_znaku
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_liczba_calkowita_bez_znaku_in_liczba_bez_znaku467);
                    liczba_calkowita_bez_znaku38=liczba_calkowita_bez_znaku();

                    state._fsp--;

                    adaptor.addChild(root_0, liczba_calkowita_bez_znaku38.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:78:7: liczba_rzeczywista_bez_znaku
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_liczba_rzeczywista_bez_znaku_in_liczba_bez_znaku475);
                    liczba_rzeczywista_bez_znaku39=liczba_rzeczywista_bez_znaku();

                    state._fsp--;

                    adaptor.addChild(root_0, liczba_rzeczywista_bez_znaku39.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "liczba_bez_znaku"

    public static class liczba_calkowita_bez_znaku_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "liczba_calkowita_bez_znaku"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:81:1: liczba_calkowita_bez_znaku : NUM_INT ;
    public final pascalParser.liczba_calkowita_bez_znaku_return liczba_calkowita_bez_znaku() throws RecognitionException {
        pascalParser.liczba_calkowita_bez_znaku_return retval = new pascalParser.liczba_calkowita_bez_znaku_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token NUM_INT40=null;

        Object NUM_INT40_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:82:5: ( NUM_INT )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:82:7: NUM_INT
            {
            root_0 = (Object)adaptor.nil();

            NUM_INT40=(Token)match(input,NUM_INT,FOLLOW_NUM_INT_in_liczba_calkowita_bez_znaku492); 
            NUM_INT40_tree = (Object)adaptor.create(NUM_INT40);
            adaptor.addChild(root_0, NUM_INT40_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "liczba_calkowita_bez_znaku"

    public static class liczba_rzeczywista_bez_znaku_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "liczba_rzeczywista_bez_znaku"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:85:1: liczba_rzeczywista_bez_znaku : NUM_REAL ;
    public final pascalParser.liczba_rzeczywista_bez_znaku_return liczba_rzeczywista_bez_znaku() throws RecognitionException {
        pascalParser.liczba_rzeczywista_bez_znaku_return retval = new pascalParser.liczba_rzeczywista_bez_znaku_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token NUM_REAL41=null;

        Object NUM_REAL41_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:86:5: ( NUM_REAL )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:86:7: NUM_REAL
            {
            root_0 = (Object)adaptor.nil();

            NUM_REAL41=(Token)match(input,NUM_REAL,FOLLOW_NUM_REAL_in_liczba_rzeczywista_bez_znaku509); 
            NUM_REAL41_tree = (Object)adaptor.create(NUM_REAL41);
            adaptor.addChild(root_0, NUM_REAL41_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "liczba_rzeczywista_bez_znaku"

    public static class znak_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "znak"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:89:1: znak : ( PLUS | MINUS );
    public final pascalParser.znak_return znak() throws RecognitionException {
        pascalParser.znak_return retval = new pascalParser.znak_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token set42=null;

        Object set42_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:90:5: ( PLUS | MINUS )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:
            {
            root_0 = (Object)adaptor.nil();

            set42=(Token)input.LT(1);
            if ( (input.LA(1)>=PLUS && input.LA(1)<=MINUS) ) {
                input.consume();
                adaptor.addChild(root_0, (Object)adaptor.create(set42));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "znak"

    public static class napis_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "napis"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:93:1: napis : STRING_LITERAL ;
    public final pascalParser.napis_return napis() throws RecognitionException {
        pascalParser.napis_return retval = new pascalParser.napis_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token STRING_LITERAL43=null;

        Object STRING_LITERAL43_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:94:5: ( STRING_LITERAL )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:94:7: STRING_LITERAL
            {
            root_0 = (Object)adaptor.nil();

            STRING_LITERAL43=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_napis547); 
            STRING_LITERAL43_tree = (Object)adaptor.create(STRING_LITERAL43);
            adaptor.addChild(root_0, STRING_LITERAL43_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "napis"

    public static class czesc_definiujaca_typy_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "czesc_definiujaca_typy"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:97:1: czesc_definiujaca_typy : TYPE definicja_typu ( SREDNIK definicja_typu )* SREDNIK -> ^( TYPE ( definicja_typu )+ ) ;
    public final pascalParser.czesc_definiujaca_typy_return czesc_definiujaca_typy() throws RecognitionException {
        pascalParser.czesc_definiujaca_typy_return retval = new pascalParser.czesc_definiujaca_typy_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token TYPE44=null;
        Token SREDNIK46=null;
        Token SREDNIK48=null;
        pascalParser.definicja_typu_return definicja_typu45 = null;

        pascalParser.definicja_typu_return definicja_typu47 = null;


        Object TYPE44_tree=null;
        Object SREDNIK46_tree=null;
        Object SREDNIK48_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleTokenStream stream_TYPE=new RewriteRuleTokenStream(adaptor,"token TYPE");
        RewriteRuleSubtreeStream stream_definicja_typu=new RewriteRuleSubtreeStream(adaptor,"rule definicja_typu");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:98:5: ( TYPE definicja_typu ( SREDNIK definicja_typu )* SREDNIK -> ^( TYPE ( definicja_typu )+ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:98:7: TYPE definicja_typu ( SREDNIK definicja_typu )* SREDNIK
            {
            TYPE44=(Token)match(input,TYPE,FOLLOW_TYPE_in_czesc_definiujaca_typy564);  
            stream_TYPE.add(TYPE44);

            pushFollow(FOLLOW_definicja_typu_in_czesc_definiujaca_typy566);
            definicja_typu45=definicja_typu();

            state._fsp--;

            stream_definicja_typu.add(definicja_typu45.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:98:27: ( SREDNIK definicja_typu )*
            loop7:
            do {
                int alt7=2;
                int LA7_0 = input.LA(1);

                if ( (LA7_0==SREDNIK) ) {
                    int LA7_1 = input.LA(2);

                    if ( (LA7_1==IDENT) ) {
                        alt7=1;
                    }


                }


                switch (alt7) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:98:29: SREDNIK definicja_typu
            	    {
            	    SREDNIK46=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_definiujaca_typy570);  
            	    stream_SREDNIK.add(SREDNIK46);

            	    pushFollow(FOLLOW_definicja_typu_in_czesc_definiujaca_typy572);
            	    definicja_typu47=definicja_typu();

            	    state._fsp--;

            	    stream_definicja_typu.add(definicja_typu47.getTree());

            	    }
            	    break;

            	default :
            	    break loop7;
                }
            } while (true);

            SREDNIK48=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_definiujaca_typy577);  
            stream_SREDNIK.add(SREDNIK48);



            // AST REWRITE
            // elements: definicja_typu, TYPE
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 98:63: -> ^( TYPE ( definicja_typu )+ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:98:66: ^( TYPE ( definicja_typu )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_TYPE.nextNode(), root_1);

                if ( !(stream_definicja_typu.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_definicja_typu.hasNext() ) {
                    adaptor.addChild(root_1, stream_definicja_typu.nextTree());

                }
                stream_definicja_typu.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "czesc_definiujaca_typy"

    public static class definicja_typu_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "definicja_typu"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:101:1: definicja_typu : identyfikator ROWNOSC ( nowy_typ ) -> ^( TYPEDECL identyfikator nowy_typ ) ;
    public final pascalParser.definicja_typu_return definicja_typu() throws RecognitionException {
        pascalParser.definicja_typu_return retval = new pascalParser.definicja_typu_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token ROWNOSC50=null;
        pascalParser.identyfikator_return identyfikator49 = null;

        pascalParser.nowy_typ_return nowy_typ51 = null;


        Object ROWNOSC50_tree=null;
        RewriteRuleTokenStream stream_ROWNOSC=new RewriteRuleTokenStream(adaptor,"token ROWNOSC");
        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        RewriteRuleSubtreeStream stream_nowy_typ=new RewriteRuleSubtreeStream(adaptor,"rule nowy_typ");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:102:5: ( identyfikator ROWNOSC ( nowy_typ ) -> ^( TYPEDECL identyfikator nowy_typ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:102:7: identyfikator ROWNOSC ( nowy_typ )
            {
            pushFollow(FOLLOW_identyfikator_in_definicja_typu603);
            identyfikator49=identyfikator();

            state._fsp--;

            stream_identyfikator.add(identyfikator49.getTree());
            ROWNOSC50=(Token)match(input,ROWNOSC,FOLLOW_ROWNOSC_in_definicja_typu605);  
            stream_ROWNOSC.add(ROWNOSC50);

            // /home/ravn/Workspace/pascal4j/src/pascal.g:102:29: ( nowy_typ )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:102:31: nowy_typ
            {
            pushFollow(FOLLOW_nowy_typ_in_definicja_typu609);
            nowy_typ51=nowy_typ();

            state._fsp--;

            stream_nowy_typ.add(nowy_typ51.getTree());

            }



            // AST REWRITE
            // elements: nowy_typ, identyfikator
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 102:42: -> ^( TYPEDECL identyfikator nowy_typ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:102:45: ^( TYPEDECL identyfikator nowy_typ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TYPEDECL, "TYPEDECL"), root_1);

                adaptor.addChild(root_1, stream_identyfikator.nextTree());
                adaptor.addChild(root_1, stream_nowy_typ.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "definicja_typu"

    public static class nowy_typ_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "nowy_typ"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:105:1: nowy_typ : ( nowy_typ_prosty | nowy_typ_strukturalny | nowy_typ_wskaznikowy );
    public final pascalParser.nowy_typ_return nowy_typ() throws RecognitionException {
        pascalParser.nowy_typ_return retval = new pascalParser.nowy_typ_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.nowy_typ_prosty_return nowy_typ_prosty52 = null;

        pascalParser.nowy_typ_strukturalny_return nowy_typ_strukturalny53 = null;

        pascalParser.nowy_typ_wskaznikowy_return nowy_typ_wskaznikowy54 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:106:5: ( nowy_typ_prosty | nowy_typ_strukturalny | nowy_typ_wskaznikowy )
            int alt8=3;
            switch ( input.LA(1) ) {
            case LNAWIAS:
            case IDENT:
            case NUM_INT:
            case NUM_REAL:
            case PLUS:
            case MINUS:
            case STRING_LITERAL:
            case CHAR:
            case BOOLEAN:
            case INTEGER:
            case REAL:
            case STRING:
                {
                alt8=1;
                }
                break;
            case PACKED:
            case ARRAY:
            case RECORD:
                {
                alt8=2;
                }
                break;
            case WSKAZNIK:
                {
                alt8=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;
            }

            switch (alt8) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:106:7: nowy_typ_prosty
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_nowy_typ_prosty_in_nowy_typ638);
                    nowy_typ_prosty52=nowy_typ_prosty();

                    state._fsp--;

                    adaptor.addChild(root_0, nowy_typ_prosty52.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:107:7: nowy_typ_strukturalny
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_nowy_typ_strukturalny_in_nowy_typ646);
                    nowy_typ_strukturalny53=nowy_typ_strukturalny();

                    state._fsp--;

                    adaptor.addChild(root_0, nowy_typ_strukturalny53.getTree());

                    }
                    break;
                case 3 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:108:7: nowy_typ_wskaznikowy
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_nowy_typ_wskaznikowy_in_nowy_typ654);
                    nowy_typ_wskaznikowy54=nowy_typ_wskaznikowy();

                    state._fsp--;

                    adaptor.addChild(root_0, nowy_typ_wskaznikowy54.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "nowy_typ"

    public static class nowy_typ_prosty_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "nowy_typ_prosty"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:111:1: nowy_typ_prosty : ( typ_wyliczeniowy | typ_okrojony | identyfikator_typu | stringtype );
    public final pascalParser.nowy_typ_prosty_return nowy_typ_prosty() throws RecognitionException {
        pascalParser.nowy_typ_prosty_return retval = new pascalParser.nowy_typ_prosty_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.typ_wyliczeniowy_return typ_wyliczeniowy55 = null;

        pascalParser.typ_okrojony_return typ_okrojony56 = null;

        pascalParser.identyfikator_typu_return identyfikator_typu57 = null;

        pascalParser.stringtype_return stringtype58 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:112:5: ( typ_wyliczeniowy | typ_okrojony | identyfikator_typu | stringtype )
            int alt9=4;
            switch ( input.LA(1) ) {
            case LNAWIAS:
                {
                alt9=1;
                }
                break;
            case NUM_INT:
            case NUM_REAL:
            case PLUS:
            case MINUS:
            case STRING_LITERAL:
                {
                alt9=2;
                }
                break;
            case IDENT:
                {
                int LA9_3 = input.LA(2);

                if ( (LA9_3==DWIEKROPKI) ) {
                    alt9=2;
                }
                else if ( ((LA9_3>=PNAWIAS && LA9_3<=SREDNIK)||LA9_3==PRZECINEK||LA9_3==PNAWIASKWADRATOWY||LA9_3==PNAWIAS2||LA9_3==END) ) {
                    alt9=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 9, 3, input);

                    throw nvae;
                }
                }
                break;
            case CHAR:
            case BOOLEAN:
            case INTEGER:
            case REAL:
                {
                alt9=3;
                }
                break;
            case STRING:
                {
                int LA9_5 = input.LA(2);

                if ( (LA9_5==LNAWIAS) ) {
                    alt9=4;
                }
                else if ( ((LA9_5>=PNAWIAS && LA9_5<=SREDNIK)||LA9_5==PRZECINEK||LA9_5==PNAWIASKWADRATOWY||LA9_5==PNAWIAS2||LA9_5==END) ) {
                    alt9=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 9, 5, input);

                    throw nvae;
                }
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;
            }

            switch (alt9) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:112:7: typ_wyliczeniowy
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_typ_wyliczeniowy_in_nowy_typ_prosty671);
                    typ_wyliczeniowy55=typ_wyliczeniowy();

                    state._fsp--;

                    adaptor.addChild(root_0, typ_wyliczeniowy55.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:113:7: typ_okrojony
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_typ_okrojony_in_nowy_typ_prosty679);
                    typ_okrojony56=typ_okrojony();

                    state._fsp--;

                    adaptor.addChild(root_0, typ_okrojony56.getTree());

                    }
                    break;
                case 3 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:114:7: identyfikator_typu
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_identyfikator_typu_in_nowy_typ_prosty687);
                    identyfikator_typu57=identyfikator_typu();

                    state._fsp--;

                    adaptor.addChild(root_0, identyfikator_typu57.getTree());

                    }
                    break;
                case 4 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:115:7: stringtype
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_stringtype_in_nowy_typ_prosty695);
                    stringtype58=stringtype();

                    state._fsp--;

                    adaptor.addChild(root_0, stringtype58.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "nowy_typ_prosty"

    public static class typ_wyliczeniowy_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typ_wyliczeniowy"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:118:1: typ_wyliczeniowy : LNAWIAS lista_identyfikatorow PNAWIAS -> ^( SCALARTYPE lista_identyfikatorow ) ;
    public final pascalParser.typ_wyliczeniowy_return typ_wyliczeniowy() throws RecognitionException {
        pascalParser.typ_wyliczeniowy_return retval = new pascalParser.typ_wyliczeniowy_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token LNAWIAS59=null;
        Token PNAWIAS61=null;
        pascalParser.lista_identyfikatorow_return lista_identyfikatorow60 = null;


        Object LNAWIAS59_tree=null;
        Object PNAWIAS61_tree=null;
        RewriteRuleTokenStream stream_LNAWIAS=new RewriteRuleTokenStream(adaptor,"token LNAWIAS");
        RewriteRuleTokenStream stream_PNAWIAS=new RewriteRuleTokenStream(adaptor,"token PNAWIAS");
        RewriteRuleSubtreeStream stream_lista_identyfikatorow=new RewriteRuleSubtreeStream(adaptor,"rule lista_identyfikatorow");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:119:5: ( LNAWIAS lista_identyfikatorow PNAWIAS -> ^( SCALARTYPE lista_identyfikatorow ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:119:7: LNAWIAS lista_identyfikatorow PNAWIAS
            {
            LNAWIAS59=(Token)match(input,LNAWIAS,FOLLOW_LNAWIAS_in_typ_wyliczeniowy712);  
            stream_LNAWIAS.add(LNAWIAS59);

            pushFollow(FOLLOW_lista_identyfikatorow_in_typ_wyliczeniowy714);
            lista_identyfikatorow60=lista_identyfikatorow();

            state._fsp--;

            stream_lista_identyfikatorow.add(lista_identyfikatorow60.getTree());
            PNAWIAS61=(Token)match(input,PNAWIAS,FOLLOW_PNAWIAS_in_typ_wyliczeniowy716);  
            stream_PNAWIAS.add(PNAWIAS61);



            // AST REWRITE
            // elements: lista_identyfikatorow
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 119:45: -> ^( SCALARTYPE lista_identyfikatorow )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:119:48: ^( SCALARTYPE lista_identyfikatorow )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(SCALARTYPE, "SCALARTYPE"), root_1);

                adaptor.addChild(root_1, stream_lista_identyfikatorow.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "typ_wyliczeniowy"

    public static class typ_okrojony_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typ_okrojony"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:122:1: typ_okrojony : stala DWIEKROPKI stala -> ^( DWIEKROPKI stala stala ) ;
    public final pascalParser.typ_okrojony_return typ_okrojony() throws RecognitionException {
        pascalParser.typ_okrojony_return retval = new pascalParser.typ_okrojony_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token DWIEKROPKI63=null;
        pascalParser.stala_return stala62 = null;

        pascalParser.stala_return stala64 = null;


        Object DWIEKROPKI63_tree=null;
        RewriteRuleTokenStream stream_DWIEKROPKI=new RewriteRuleTokenStream(adaptor,"token DWIEKROPKI");
        RewriteRuleSubtreeStream stream_stala=new RewriteRuleSubtreeStream(adaptor,"rule stala");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:123:5: ( stala DWIEKROPKI stala -> ^( DWIEKROPKI stala stala ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:123:7: stala DWIEKROPKI stala
            {
            pushFollow(FOLLOW_stala_in_typ_okrojony741);
            stala62=stala();

            state._fsp--;

            stream_stala.add(stala62.getTree());
            DWIEKROPKI63=(Token)match(input,DWIEKROPKI,FOLLOW_DWIEKROPKI_in_typ_okrojony743);  
            stream_DWIEKROPKI.add(DWIEKROPKI63);

            pushFollow(FOLLOW_stala_in_typ_okrojony745);
            stala64=stala();

            state._fsp--;

            stream_stala.add(stala64.getTree());


            // AST REWRITE
            // elements: stala, stala, DWIEKROPKI
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 123:30: -> ^( DWIEKROPKI stala stala )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:123:33: ^( DWIEKROPKI stala stala )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_DWIEKROPKI.nextNode(), root_1);

                adaptor.addChild(root_1, stream_stala.nextTree());
                adaptor.addChild(root_1, stream_stala.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "typ_okrojony"

    public static class identyfikator_typu_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "identyfikator_typu"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:126:1: identyfikator_typu : ( identyfikator | CHAR | BOOLEAN | INTEGER | REAL | STRING );
    public final pascalParser.identyfikator_typu_return identyfikator_typu() throws RecognitionException {
        pascalParser.identyfikator_typu_return retval = new pascalParser.identyfikator_typu_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token CHAR66=null;
        Token BOOLEAN67=null;
        Token INTEGER68=null;
        Token REAL69=null;
        Token STRING70=null;
        pascalParser.identyfikator_return identyfikator65 = null;


        Object CHAR66_tree=null;
        Object BOOLEAN67_tree=null;
        Object INTEGER68_tree=null;
        Object REAL69_tree=null;
        Object STRING70_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:127:5: ( identyfikator | CHAR | BOOLEAN | INTEGER | REAL | STRING )
            int alt10=6;
            switch ( input.LA(1) ) {
            case IDENT:
                {
                alt10=1;
                }
                break;
            case CHAR:
                {
                alt10=2;
                }
                break;
            case BOOLEAN:
                {
                alt10=3;
                }
                break;
            case INTEGER:
                {
                alt10=4;
                }
                break;
            case REAL:
                {
                alt10=5;
                }
                break;
            case STRING:
                {
                alt10=6;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;
            }

            switch (alt10) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:127:7: identyfikator
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_identyfikator_in_identyfikator_typu772);
                    identyfikator65=identyfikator();

                    state._fsp--;

                    adaptor.addChild(root_0, identyfikator65.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:128:7: CHAR
                    {
                    root_0 = (Object)adaptor.nil();

                    CHAR66=(Token)match(input,CHAR,FOLLOW_CHAR_in_identyfikator_typu780); 
                    CHAR66_tree = (Object)adaptor.create(CHAR66);
                    adaptor.addChild(root_0, CHAR66_tree);


                    }
                    break;
                case 3 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:129:7: BOOLEAN
                    {
                    root_0 = (Object)adaptor.nil();

                    BOOLEAN67=(Token)match(input,BOOLEAN,FOLLOW_BOOLEAN_in_identyfikator_typu788); 
                    BOOLEAN67_tree = (Object)adaptor.create(BOOLEAN67);
                    adaptor.addChild(root_0, BOOLEAN67_tree);


                    }
                    break;
                case 4 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:130:7: INTEGER
                    {
                    root_0 = (Object)adaptor.nil();

                    INTEGER68=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_identyfikator_typu796); 
                    INTEGER68_tree = (Object)adaptor.create(INTEGER68);
                    adaptor.addChild(root_0, INTEGER68_tree);


                    }
                    break;
                case 5 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:131:7: REAL
                    {
                    root_0 = (Object)adaptor.nil();

                    REAL69=(Token)match(input,REAL,FOLLOW_REAL_in_identyfikator_typu804); 
                    REAL69_tree = (Object)adaptor.create(REAL69);
                    adaptor.addChild(root_0, REAL69_tree);


                    }
                    break;
                case 6 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:132:7: STRING
                    {
                    root_0 = (Object)adaptor.nil();

                    STRING70=(Token)match(input,STRING,FOLLOW_STRING_in_identyfikator_typu812); 
                    STRING70_tree = (Object)adaptor.create(STRING70);
                    adaptor.addChild(root_0, STRING70_tree);


                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "identyfikator_typu"

    public static class nowy_typ_strukturalny_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "nowy_typ_strukturalny"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:135:1: nowy_typ_strukturalny : ( PACKED typ_strukturalny_niespakowany -> ^( PACKED typ_strukturalny_niespakowany ) | typ_strukturalny_niespakowany );
    public final pascalParser.nowy_typ_strukturalny_return nowy_typ_strukturalny() throws RecognitionException {
        pascalParser.nowy_typ_strukturalny_return retval = new pascalParser.nowy_typ_strukturalny_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PACKED71=null;
        pascalParser.typ_strukturalny_niespakowany_return typ_strukturalny_niespakowany72 = null;

        pascalParser.typ_strukturalny_niespakowany_return typ_strukturalny_niespakowany73 = null;


        Object PACKED71_tree=null;
        RewriteRuleTokenStream stream_PACKED=new RewriteRuleTokenStream(adaptor,"token PACKED");
        RewriteRuleSubtreeStream stream_typ_strukturalny_niespakowany=new RewriteRuleSubtreeStream(adaptor,"rule typ_strukturalny_niespakowany");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:136:5: ( PACKED typ_strukturalny_niespakowany -> ^( PACKED typ_strukturalny_niespakowany ) | typ_strukturalny_niespakowany )
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0==PACKED) ) {
                alt11=1;
            }
            else if ( (LA11_0==ARRAY||LA11_0==RECORD) ) {
                alt11=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }
            switch (alt11) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:136:7: PACKED typ_strukturalny_niespakowany
                    {
                    PACKED71=(Token)match(input,PACKED,FOLLOW_PACKED_in_nowy_typ_strukturalny829);  
                    stream_PACKED.add(PACKED71);

                    pushFollow(FOLLOW_typ_strukturalny_niespakowany_in_nowy_typ_strukturalny831);
                    typ_strukturalny_niespakowany72=typ_strukturalny_niespakowany();

                    state._fsp--;

                    stream_typ_strukturalny_niespakowany.add(typ_strukturalny_niespakowany72.getTree());


                    // AST REWRITE
                    // elements: typ_strukturalny_niespakowany, PACKED
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 136:44: -> ^( PACKED typ_strukturalny_niespakowany )
                    {
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:136:47: ^( PACKED typ_strukturalny_niespakowany )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_PACKED.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_typ_strukturalny_niespakowany.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:137:7: typ_strukturalny_niespakowany
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_typ_strukturalny_niespakowany_in_nowy_typ_strukturalny847);
                    typ_strukturalny_niespakowany73=typ_strukturalny_niespakowany();

                    state._fsp--;

                    adaptor.addChild(root_0, typ_strukturalny_niespakowany73.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "nowy_typ_strukturalny"

    public static class typ_strukturalny_niespakowany_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typ_strukturalny_niespakowany"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:140:1: typ_strukturalny_niespakowany : ( typ_tablicowy | typ_rekordowy );
    public final pascalParser.typ_strukturalny_niespakowany_return typ_strukturalny_niespakowany() throws RecognitionException {
        pascalParser.typ_strukturalny_niespakowany_return retval = new pascalParser.typ_strukturalny_niespakowany_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.typ_tablicowy_return typ_tablicowy74 = null;

        pascalParser.typ_rekordowy_return typ_rekordowy75 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:141:5: ( typ_tablicowy | typ_rekordowy )
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( (LA12_0==ARRAY) ) {
                alt12=1;
            }
            else if ( (LA12_0==RECORD) ) {
                alt12=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }
            switch (alt12) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:141:7: typ_tablicowy
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_typ_tablicowy_in_typ_strukturalny_niespakowany864);
                    typ_tablicowy74=typ_tablicowy();

                    state._fsp--;

                    adaptor.addChild(root_0, typ_tablicowy74.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:142:7: typ_rekordowy
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_typ_rekordowy_in_typ_strukturalny_niespakowany872);
                    typ_rekordowy75=typ_rekordowy();

                    state._fsp--;

                    adaptor.addChild(root_0, typ_rekordowy75.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "typ_strukturalny_niespakowany"

    public static class stringtype_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "stringtype"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:145:1: stringtype : STRING LNAWIAS ( identyfikator | liczba_bez_znaku ) PNAWIAS ;
    public final pascalParser.stringtype_return stringtype() throws RecognitionException {
        pascalParser.stringtype_return retval = new pascalParser.stringtype_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token STRING76=null;
        Token LNAWIAS77=null;
        Token PNAWIAS80=null;
        pascalParser.identyfikator_return identyfikator78 = null;

        pascalParser.liczba_bez_znaku_return liczba_bez_znaku79 = null;


        Object STRING76_tree=null;
        Object LNAWIAS77_tree=null;
        Object PNAWIAS80_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:146:5: ( STRING LNAWIAS ( identyfikator | liczba_bez_znaku ) PNAWIAS )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:146:7: STRING LNAWIAS ( identyfikator | liczba_bez_znaku ) PNAWIAS
            {
            root_0 = (Object)adaptor.nil();

            STRING76=(Token)match(input,STRING,FOLLOW_STRING_in_stringtype889); 
            STRING76_tree = (Object)adaptor.create(STRING76);
            root_0 = (Object)adaptor.becomeRoot(STRING76_tree, root_0);

            LNAWIAS77=(Token)match(input,LNAWIAS,FOLLOW_LNAWIAS_in_stringtype892); 
            // /home/ravn/Workspace/pascal4j/src/pascal.g:146:24: ( identyfikator | liczba_bez_znaku )
            int alt13=2;
            int LA13_0 = input.LA(1);

            if ( (LA13_0==IDENT) ) {
                alt13=1;
            }
            else if ( ((LA13_0>=NUM_INT && LA13_0<=NUM_REAL)) ) {
                alt13=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;
            }
            switch (alt13) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:146:25: identyfikator
                    {
                    pushFollow(FOLLOW_identyfikator_in_stringtype896);
                    identyfikator78=identyfikator();

                    state._fsp--;

                    adaptor.addChild(root_0, identyfikator78.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:146:39: liczba_bez_znaku
                    {
                    pushFollow(FOLLOW_liczba_bez_znaku_in_stringtype898);
                    liczba_bez_znaku79=liczba_bez_znaku();

                    state._fsp--;

                    adaptor.addChild(root_0, liczba_bez_znaku79.getTree());

                    }
                    break;

            }

            PNAWIAS80=(Token)match(input,PNAWIAS,FOLLOW_PNAWIAS_in_stringtype901); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "stringtype"

    public static class typ_tablicowy_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typ_tablicowy"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:149:1: typ_tablicowy : ( ARRAY LNAWIASKWADRATOWY lista_typow_indeksowych PNAWIASKWADRATOWY OF typ_skladowy -> ^( ARRAY lista_typow_indeksowych typ_skladowy ) | ARRAY LNAWIAS2 lista_typow_indeksowych PNAWIAS2 OF typ_skladowy -> ^( ARRAY lista_typow_indeksowych typ_skladowy ) );
    public final pascalParser.typ_tablicowy_return typ_tablicowy() throws RecognitionException {
        pascalParser.typ_tablicowy_return retval = new pascalParser.typ_tablicowy_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token ARRAY81=null;
        Token LNAWIASKWADRATOWY82=null;
        Token PNAWIASKWADRATOWY84=null;
        Token OF85=null;
        Token ARRAY87=null;
        Token LNAWIAS288=null;
        Token PNAWIAS290=null;
        Token OF91=null;
        pascalParser.lista_typow_indeksowych_return lista_typow_indeksowych83 = null;

        pascalParser.typ_skladowy_return typ_skladowy86 = null;

        pascalParser.lista_typow_indeksowych_return lista_typow_indeksowych89 = null;

        pascalParser.typ_skladowy_return typ_skladowy92 = null;


        Object ARRAY81_tree=null;
        Object LNAWIASKWADRATOWY82_tree=null;
        Object PNAWIASKWADRATOWY84_tree=null;
        Object OF85_tree=null;
        Object ARRAY87_tree=null;
        Object LNAWIAS288_tree=null;
        Object PNAWIAS290_tree=null;
        Object OF91_tree=null;
        RewriteRuleTokenStream stream_PNAWIASKWADRATOWY=new RewriteRuleTokenStream(adaptor,"token PNAWIASKWADRATOWY");
        RewriteRuleTokenStream stream_LNAWIASKWADRATOWY=new RewriteRuleTokenStream(adaptor,"token LNAWIASKWADRATOWY");
        RewriteRuleTokenStream stream_PNAWIAS2=new RewriteRuleTokenStream(adaptor,"token PNAWIAS2");
        RewriteRuleTokenStream stream_OF=new RewriteRuleTokenStream(adaptor,"token OF");
        RewriteRuleTokenStream stream_ARRAY=new RewriteRuleTokenStream(adaptor,"token ARRAY");
        RewriteRuleTokenStream stream_LNAWIAS2=new RewriteRuleTokenStream(adaptor,"token LNAWIAS2");
        RewriteRuleSubtreeStream stream_typ_skladowy=new RewriteRuleSubtreeStream(adaptor,"rule typ_skladowy");
        RewriteRuleSubtreeStream stream_lista_typow_indeksowych=new RewriteRuleSubtreeStream(adaptor,"rule lista_typow_indeksowych");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:150:5: ( ARRAY LNAWIASKWADRATOWY lista_typow_indeksowych PNAWIASKWADRATOWY OF typ_skladowy -> ^( ARRAY lista_typow_indeksowych typ_skladowy ) | ARRAY LNAWIAS2 lista_typow_indeksowych PNAWIAS2 OF typ_skladowy -> ^( ARRAY lista_typow_indeksowych typ_skladowy ) )
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0==ARRAY) ) {
                int LA14_1 = input.LA(2);

                if ( (LA14_1==LNAWIASKWADRATOWY) ) {
                    alt14=1;
                }
                else if ( (LA14_1==LNAWIAS2) ) {
                    alt14=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 14, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;
            }
            switch (alt14) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:150:7: ARRAY LNAWIASKWADRATOWY lista_typow_indeksowych PNAWIASKWADRATOWY OF typ_skladowy
                    {
                    ARRAY81=(Token)match(input,ARRAY,FOLLOW_ARRAY_in_typ_tablicowy919);  
                    stream_ARRAY.add(ARRAY81);

                    LNAWIASKWADRATOWY82=(Token)match(input,LNAWIASKWADRATOWY,FOLLOW_LNAWIASKWADRATOWY_in_typ_tablicowy921);  
                    stream_LNAWIASKWADRATOWY.add(LNAWIASKWADRATOWY82);

                    pushFollow(FOLLOW_lista_typow_indeksowych_in_typ_tablicowy923);
                    lista_typow_indeksowych83=lista_typow_indeksowych();

                    state._fsp--;

                    stream_lista_typow_indeksowych.add(lista_typow_indeksowych83.getTree());
                    PNAWIASKWADRATOWY84=(Token)match(input,PNAWIASKWADRATOWY,FOLLOW_PNAWIASKWADRATOWY_in_typ_tablicowy925);  
                    stream_PNAWIASKWADRATOWY.add(PNAWIASKWADRATOWY84);

                    OF85=(Token)match(input,OF,FOLLOW_OF_in_typ_tablicowy927);  
                    stream_OF.add(OF85);

                    pushFollow(FOLLOW_typ_skladowy_in_typ_tablicowy929);
                    typ_skladowy86=typ_skladowy();

                    state._fsp--;

                    stream_typ_skladowy.add(typ_skladowy86.getTree());


                    // AST REWRITE
                    // elements: ARRAY, typ_skladowy, lista_typow_indeksowych
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 150:89: -> ^( ARRAY lista_typow_indeksowych typ_skladowy )
                    {
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:150:92: ^( ARRAY lista_typow_indeksowych typ_skladowy )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_ARRAY.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_lista_typow_indeksowych.nextTree());
                        adaptor.addChild(root_1, stream_typ_skladowy.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:151:7: ARRAY LNAWIAS2 lista_typow_indeksowych PNAWIAS2 OF typ_skladowy
                    {
                    ARRAY87=(Token)match(input,ARRAY,FOLLOW_ARRAY_in_typ_tablicowy947);  
                    stream_ARRAY.add(ARRAY87);

                    LNAWIAS288=(Token)match(input,LNAWIAS2,FOLLOW_LNAWIAS2_in_typ_tablicowy949);  
                    stream_LNAWIAS2.add(LNAWIAS288);

                    pushFollow(FOLLOW_lista_typow_indeksowych_in_typ_tablicowy951);
                    lista_typow_indeksowych89=lista_typow_indeksowych();

                    state._fsp--;

                    stream_lista_typow_indeksowych.add(lista_typow_indeksowych89.getTree());
                    PNAWIAS290=(Token)match(input,PNAWIAS2,FOLLOW_PNAWIAS2_in_typ_tablicowy953);  
                    stream_PNAWIAS2.add(PNAWIAS290);

                    OF91=(Token)match(input,OF,FOLLOW_OF_in_typ_tablicowy955);  
                    stream_OF.add(OF91);

                    pushFollow(FOLLOW_typ_skladowy_in_typ_tablicowy957);
                    typ_skladowy92=typ_skladowy();

                    state._fsp--;

                    stream_typ_skladowy.add(typ_skladowy92.getTree());


                    // AST REWRITE
                    // elements: lista_typow_indeksowych, typ_skladowy, ARRAY
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 151:71: -> ^( ARRAY lista_typow_indeksowych typ_skladowy )
                    {
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:151:74: ^( ARRAY lista_typow_indeksowych typ_skladowy )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_ARRAY.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_lista_typow_indeksowych.nextTree());
                        adaptor.addChild(root_1, stream_typ_skladowy.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "typ_tablicowy"

    public static class lista_typow_indeksowych_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "lista_typow_indeksowych"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:154:1: lista_typow_indeksowych : typ_indeksowy ( PRZECINEK typ_indeksowy )* -> ^( TYPELIST ( typ_indeksowy )+ ) ;
    public final pascalParser.lista_typow_indeksowych_return lista_typow_indeksowych() throws RecognitionException {
        pascalParser.lista_typow_indeksowych_return retval = new pascalParser.lista_typow_indeksowych_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PRZECINEK94=null;
        pascalParser.typ_indeksowy_return typ_indeksowy93 = null;

        pascalParser.typ_indeksowy_return typ_indeksowy95 = null;


        Object PRZECINEK94_tree=null;
        RewriteRuleTokenStream stream_PRZECINEK=new RewriteRuleTokenStream(adaptor,"token PRZECINEK");
        RewriteRuleSubtreeStream stream_typ_indeksowy=new RewriteRuleSubtreeStream(adaptor,"rule typ_indeksowy");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:155:2: ( typ_indeksowy ( PRZECINEK typ_indeksowy )* -> ^( TYPELIST ( typ_indeksowy )+ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:155:4: typ_indeksowy ( PRZECINEK typ_indeksowy )*
            {
            pushFollow(FOLLOW_typ_indeksowy_in_lista_typow_indeksowych978);
            typ_indeksowy93=typ_indeksowy();

            state._fsp--;

            stream_typ_indeksowy.add(typ_indeksowy93.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:155:18: ( PRZECINEK typ_indeksowy )*
            loop15:
            do {
                int alt15=2;
                int LA15_0 = input.LA(1);

                if ( (LA15_0==PRZECINEK) ) {
                    alt15=1;
                }


                switch (alt15) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:155:20: PRZECINEK typ_indeksowy
            	    {
            	    PRZECINEK94=(Token)match(input,PRZECINEK,FOLLOW_PRZECINEK_in_lista_typow_indeksowych982);  
            	    stream_PRZECINEK.add(PRZECINEK94);

            	    pushFollow(FOLLOW_typ_indeksowy_in_lista_typow_indeksowych984);
            	    typ_indeksowy95=typ_indeksowy();

            	    state._fsp--;

            	    stream_typ_indeksowy.add(typ_indeksowy95.getTree());

            	    }
            	    break;

            	default :
            	    break loop15;
                }
            } while (true);



            // AST REWRITE
            // elements: typ_indeksowy
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 155:47: -> ^( TYPELIST ( typ_indeksowy )+ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:155:50: ^( TYPELIST ( typ_indeksowy )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TYPELIST, "TYPELIST"), root_1);

                if ( !(stream_typ_indeksowy.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_typ_indeksowy.hasNext() ) {
                    adaptor.addChild(root_1, stream_typ_indeksowy.nextTree());

                }
                stream_typ_indeksowy.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "lista_typow_indeksowych"

    public static class typ_indeksowy_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typ_indeksowy"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:158:1: typ_indeksowy : nowy_typ_prosty ;
    public final pascalParser.typ_indeksowy_return typ_indeksowy() throws RecognitionException {
        pascalParser.typ_indeksowy_return retval = new pascalParser.typ_indeksowy_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.nowy_typ_prosty_return nowy_typ_prosty96 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:159:5: ( nowy_typ_prosty )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:159:7: nowy_typ_prosty
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_nowy_typ_prosty_in_typ_indeksowy1010);
            nowy_typ_prosty96=nowy_typ_prosty();

            state._fsp--;

            adaptor.addChild(root_0, nowy_typ_prosty96.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "typ_indeksowy"

    public static class typ_skladowy_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typ_skladowy"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:162:1: typ_skladowy : nowy_typ ;
    public final pascalParser.typ_skladowy_return typ_skladowy() throws RecognitionException {
        pascalParser.typ_skladowy_return retval = new pascalParser.typ_skladowy_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.nowy_typ_return nowy_typ97 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:163:5: ( nowy_typ )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:163:7: nowy_typ
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_nowy_typ_in_typ_skladowy1027);
            nowy_typ97=nowy_typ();

            state._fsp--;

            adaptor.addChild(root_0, nowy_typ97.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "typ_skladowy"

    public static class typ_rekordowy_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typ_rekordowy"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:166:1: typ_rekordowy : RECORD lista_pol END -> ^( RECORD lista_pol ) ;
    public final pascalParser.typ_rekordowy_return typ_rekordowy() throws RecognitionException {
        pascalParser.typ_rekordowy_return retval = new pascalParser.typ_rekordowy_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token RECORD98=null;
        Token END100=null;
        pascalParser.lista_pol_return lista_pol99 = null;


        Object RECORD98_tree=null;
        Object END100_tree=null;
        RewriteRuleTokenStream stream_RECORD=new RewriteRuleTokenStream(adaptor,"token RECORD");
        RewriteRuleTokenStream stream_END=new RewriteRuleTokenStream(adaptor,"token END");
        RewriteRuleSubtreeStream stream_lista_pol=new RewriteRuleSubtreeStream(adaptor,"rule lista_pol");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:167:5: ( RECORD lista_pol END -> ^( RECORD lista_pol ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:167:7: RECORD lista_pol END
            {
            RECORD98=(Token)match(input,RECORD,FOLLOW_RECORD_in_typ_rekordowy1044);  
            stream_RECORD.add(RECORD98);

            pushFollow(FOLLOW_lista_pol_in_typ_rekordowy1046);
            lista_pol99=lista_pol();

            state._fsp--;

            stream_lista_pol.add(lista_pol99.getTree());
            END100=(Token)match(input,END,FOLLOW_END_in_typ_rekordowy1048);  
            stream_END.add(END100);



            // AST REWRITE
            // elements: RECORD, lista_pol
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 167:28: -> ^( RECORD lista_pol )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:167:31: ^( RECORD lista_pol )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_RECORD.nextNode(), root_1);

                adaptor.addChild(root_1, stream_lista_pol.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "typ_rekordowy"

    public static class lista_pol_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "lista_pol"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:170:1: lista_pol : ( czesc_stala ( SREDNIK czesc_zmienna | SREDNIK )? -> ^( FIELDLIST czesc_stala ( czesc_zmienna )? ) | czesc_zmienna -> ^( FIELDLIST czesc_zmienna ) ) ;
    public final pascalParser.lista_pol_return lista_pol() throws RecognitionException {
        pascalParser.lista_pol_return retval = new pascalParser.lista_pol_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token SREDNIK102=null;
        Token SREDNIK104=null;
        pascalParser.czesc_stala_return czesc_stala101 = null;

        pascalParser.czesc_zmienna_return czesc_zmienna103 = null;

        pascalParser.czesc_zmienna_return czesc_zmienna105 = null;


        Object SREDNIK102_tree=null;
        Object SREDNIK104_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleSubtreeStream stream_czesc_zmienna=new RewriteRuleSubtreeStream(adaptor,"rule czesc_zmienna");
        RewriteRuleSubtreeStream stream_czesc_stala=new RewriteRuleSubtreeStream(adaptor,"rule czesc_stala");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:171:5: ( ( czesc_stala ( SREDNIK czesc_zmienna | SREDNIK )? -> ^( FIELDLIST czesc_stala ( czesc_zmienna )? ) | czesc_zmienna -> ^( FIELDLIST czesc_zmienna ) ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:171:7: ( czesc_stala ( SREDNIK czesc_zmienna | SREDNIK )? -> ^( FIELDLIST czesc_stala ( czesc_zmienna )? ) | czesc_zmienna -> ^( FIELDLIST czesc_zmienna ) )
            {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:171:7: ( czesc_stala ( SREDNIK czesc_zmienna | SREDNIK )? -> ^( FIELDLIST czesc_stala ( czesc_zmienna )? ) | czesc_zmienna -> ^( FIELDLIST czesc_zmienna ) )
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( (LA17_0==IDENT) ) {
                alt17=1;
            }
            else if ( (LA17_0==CASE) ) {
                alt17=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 17, 0, input);

                throw nvae;
            }
            switch (alt17) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:171:9: czesc_stala ( SREDNIK czesc_zmienna | SREDNIK )?
                    {
                    pushFollow(FOLLOW_czesc_stala_in_lista_pol1075);
                    czesc_stala101=czesc_stala();

                    state._fsp--;

                    stream_czesc_stala.add(czesc_stala101.getTree());
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:171:21: ( SREDNIK czesc_zmienna | SREDNIK )?
                    int alt16=3;
                    int LA16_0 = input.LA(1);

                    if ( (LA16_0==SREDNIK) ) {
                        int LA16_1 = input.LA(2);

                        if ( (LA16_1==CASE) ) {
                            alt16=1;
                        }
                        else if ( (LA16_1==PNAWIAS||LA16_1==END) ) {
                            alt16=2;
                        }
                    }
                    switch (alt16) {
                        case 1 :
                            // /home/ravn/Workspace/pascal4j/src/pascal.g:171:23: SREDNIK czesc_zmienna
                            {
                            SREDNIK102=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_lista_pol1079);  
                            stream_SREDNIK.add(SREDNIK102);

                            pushFollow(FOLLOW_czesc_zmienna_in_lista_pol1081);
                            czesc_zmienna103=czesc_zmienna();

                            state._fsp--;

                            stream_czesc_zmienna.add(czesc_zmienna103.getTree());

                            }
                            break;
                        case 2 :
                            // /home/ravn/Workspace/pascal4j/src/pascal.g:171:47: SREDNIK
                            {
                            SREDNIK104=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_lista_pol1085);  
                            stream_SREDNIK.add(SREDNIK104);


                            }
                            break;

                    }



                    // AST REWRITE
                    // elements: czesc_stala, czesc_zmienna
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 171:58: -> ^( FIELDLIST czesc_stala ( czesc_zmienna )? )
                    {
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:171:61: ^( FIELDLIST czesc_stala ( czesc_zmienna )? )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FIELDLIST, "FIELDLIST"), root_1);

                        adaptor.addChild(root_1, stream_czesc_stala.nextTree());
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:171:85: ( czesc_zmienna )?
                        if ( stream_czesc_zmienna.hasNext() ) {
                            adaptor.addChild(root_1, stream_czesc_zmienna.nextTree());

                        }
                        stream_czesc_zmienna.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:172:9: czesc_zmienna
                    {
                    pushFollow(FOLLOW_czesc_zmienna_in_lista_pol1109);
                    czesc_zmienna105=czesc_zmienna();

                    state._fsp--;

                    stream_czesc_zmienna.add(czesc_zmienna105.getTree());


                    // AST REWRITE
                    // elements: czesc_zmienna
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 172:23: -> ^( FIELDLIST czesc_zmienna )
                    {
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:172:26: ^( FIELDLIST czesc_zmienna )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FIELDLIST, "FIELDLIST"), root_1);

                        adaptor.addChild(root_1, stream_czesc_zmienna.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "lista_pol"

    public static class czesc_stala_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "czesc_stala"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:176:1: czesc_stala : sekcja_rekordu ( SREDNIK sekcja_rekordu )* ;
    public final pascalParser.czesc_stala_return czesc_stala() throws RecognitionException {
        pascalParser.czesc_stala_return retval = new pascalParser.czesc_stala_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token SREDNIK107=null;
        pascalParser.sekcja_rekordu_return sekcja_rekordu106 = null;

        pascalParser.sekcja_rekordu_return sekcja_rekordu108 = null;


        Object SREDNIK107_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:177:5: ( sekcja_rekordu ( SREDNIK sekcja_rekordu )* )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:177:7: sekcja_rekordu ( SREDNIK sekcja_rekordu )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_sekcja_rekordu_in_czesc_stala1142);
            sekcja_rekordu106=sekcja_rekordu();

            state._fsp--;

            adaptor.addChild(root_0, sekcja_rekordu106.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:177:22: ( SREDNIK sekcja_rekordu )*
            loop18:
            do {
                int alt18=2;
                int LA18_0 = input.LA(1);

                if ( (LA18_0==SREDNIK) ) {
                    int LA18_1 = input.LA(2);

                    if ( (LA18_1==IDENT) ) {
                        alt18=1;
                    }


                }


                switch (alt18) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:177:24: SREDNIK sekcja_rekordu
            	    {
            	    SREDNIK107=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_stala1146); 
            	    pushFollow(FOLLOW_sekcja_rekordu_in_czesc_stala1149);
            	    sekcja_rekordu108=sekcja_rekordu();

            	    state._fsp--;

            	    adaptor.addChild(root_0, sekcja_rekordu108.getTree());

            	    }
            	    break;

            	default :
            	    break loop18;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "czesc_stala"

    public static class sekcja_rekordu_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "sekcja_rekordu"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:180:1: sekcja_rekordu : lista_identyfikatorow DWUKROPEK nowy_typ -> ^( FIELD nowy_typ lista_identyfikatorow ) ;
    public final pascalParser.sekcja_rekordu_return sekcja_rekordu() throws RecognitionException {
        pascalParser.sekcja_rekordu_return retval = new pascalParser.sekcja_rekordu_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token DWUKROPEK110=null;
        pascalParser.lista_identyfikatorow_return lista_identyfikatorow109 = null;

        pascalParser.nowy_typ_return nowy_typ111 = null;


        Object DWUKROPEK110_tree=null;
        RewriteRuleTokenStream stream_DWUKROPEK=new RewriteRuleTokenStream(adaptor,"token DWUKROPEK");
        RewriteRuleSubtreeStream stream_nowy_typ=new RewriteRuleSubtreeStream(adaptor,"rule nowy_typ");
        RewriteRuleSubtreeStream stream_lista_identyfikatorow=new RewriteRuleSubtreeStream(adaptor,"rule lista_identyfikatorow");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:181:5: ( lista_identyfikatorow DWUKROPEK nowy_typ -> ^( FIELD nowy_typ lista_identyfikatorow ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:181:7: lista_identyfikatorow DWUKROPEK nowy_typ
            {
            pushFollow(FOLLOW_lista_identyfikatorow_in_sekcja_rekordu1169);
            lista_identyfikatorow109=lista_identyfikatorow();

            state._fsp--;

            stream_lista_identyfikatorow.add(lista_identyfikatorow109.getTree());
            DWUKROPEK110=(Token)match(input,DWUKROPEK,FOLLOW_DWUKROPEK_in_sekcja_rekordu1171);  
            stream_DWUKROPEK.add(DWUKROPEK110);

            pushFollow(FOLLOW_nowy_typ_in_sekcja_rekordu1173);
            nowy_typ111=nowy_typ();

            state._fsp--;

            stream_nowy_typ.add(nowy_typ111.getTree());


            // AST REWRITE
            // elements: nowy_typ, lista_identyfikatorow
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 181:48: -> ^( FIELD nowy_typ lista_identyfikatorow )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:181:51: ^( FIELD nowy_typ lista_identyfikatorow )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FIELD, "FIELD"), root_1);

                adaptor.addChild(root_1, stream_nowy_typ.nextTree());
                adaptor.addChild(root_1, stream_lista_identyfikatorow.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "sekcja_rekordu"

    public static class czesc_zmienna_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "czesc_zmienna"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:184:1: czesc_zmienna : CASE selektor_wariantu OF wariant ( SREDNIK wariant | SREDNIK )* -> ^( CASE selektor_wariantu ( wariant )+ ) ;
    public final pascalParser.czesc_zmienna_return czesc_zmienna() throws RecognitionException {
        pascalParser.czesc_zmienna_return retval = new pascalParser.czesc_zmienna_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token CASE112=null;
        Token OF114=null;
        Token SREDNIK116=null;
        Token SREDNIK118=null;
        pascalParser.selektor_wariantu_return selektor_wariantu113 = null;

        pascalParser.wariant_return wariant115 = null;

        pascalParser.wariant_return wariant117 = null;


        Object CASE112_tree=null;
        Object OF114_tree=null;
        Object SREDNIK116_tree=null;
        Object SREDNIK118_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleTokenStream stream_OF=new RewriteRuleTokenStream(adaptor,"token OF");
        RewriteRuleTokenStream stream_CASE=new RewriteRuleTokenStream(adaptor,"token CASE");
        RewriteRuleSubtreeStream stream_wariant=new RewriteRuleSubtreeStream(adaptor,"rule wariant");
        RewriteRuleSubtreeStream stream_selektor_wariantu=new RewriteRuleSubtreeStream(adaptor,"rule selektor_wariantu");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:185:5: ( CASE selektor_wariantu OF wariant ( SREDNIK wariant | SREDNIK )* -> ^( CASE selektor_wariantu ( wariant )+ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:185:7: CASE selektor_wariantu OF wariant ( SREDNIK wariant | SREDNIK )*
            {
            CASE112=(Token)match(input,CASE,FOLLOW_CASE_in_czesc_zmienna1200);  
            stream_CASE.add(CASE112);

            pushFollow(FOLLOW_selektor_wariantu_in_czesc_zmienna1202);
            selektor_wariantu113=selektor_wariantu();

            state._fsp--;

            stream_selektor_wariantu.add(selektor_wariantu113.getTree());
            OF114=(Token)match(input,OF,FOLLOW_OF_in_czesc_zmienna1204);  
            stream_OF.add(OF114);

            pushFollow(FOLLOW_wariant_in_czesc_zmienna1206);
            wariant115=wariant();

            state._fsp--;

            stream_wariant.add(wariant115.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:185:41: ( SREDNIK wariant | SREDNIK )*
            loop19:
            do {
                int alt19=3;
                int LA19_0 = input.LA(1);

                if ( (LA19_0==SREDNIK) ) {
                    int LA19_2 = input.LA(2);

                    if ( ((LA19_2>=PNAWIAS && LA19_2<=SREDNIK)||LA19_2==END) ) {
                        alt19=2;
                    }
                    else if ( (LA19_2==IDENT||(LA19_2>=NUM_INT && LA19_2<=STRING_LITERAL)) ) {
                        alt19=1;
                    }


                }


                switch (alt19) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:185:43: SREDNIK wariant
            	    {
            	    SREDNIK116=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_zmienna1210);  
            	    stream_SREDNIK.add(SREDNIK116);

            	    pushFollow(FOLLOW_wariant_in_czesc_zmienna1212);
            	    wariant117=wariant();

            	    state._fsp--;

            	    stream_wariant.add(wariant117.getTree());

            	    }
            	    break;
            	case 2 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:185:61: SREDNIK
            	    {
            	    SREDNIK118=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_zmienna1216);  
            	    stream_SREDNIK.add(SREDNIK118);


            	    }
            	    break;

            	default :
            	    break loop19;
                }
            } while (true);



            // AST REWRITE
            // elements: wariant, CASE, selektor_wariantu
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 185:72: -> ^( CASE selektor_wariantu ( wariant )+ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:185:75: ^( CASE selektor_wariantu ( wariant )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_CASE.nextNode(), root_1);

                adaptor.addChild(root_1, stream_selektor_wariantu.nextTree());
                if ( !(stream_wariant.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_wariant.hasNext() ) {
                    adaptor.addChild(root_1, stream_wariant.nextTree());

                }
                stream_wariant.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "czesc_zmienna"

    public static class selektor_wariantu_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "selektor_wariantu"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:188:1: selektor_wariantu : ( identyfikator DWUKROPEK identyfikator_typu -> ^( VARIANT_TAG identyfikator identyfikator_typu ) | identyfikator_typu -> ^( VARIANT_TAG_NO_ID identyfikator_typu ) );
    public final pascalParser.selektor_wariantu_return selektor_wariantu() throws RecognitionException {
        pascalParser.selektor_wariantu_return retval = new pascalParser.selektor_wariantu_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token DWUKROPEK120=null;
        pascalParser.identyfikator_return identyfikator119 = null;

        pascalParser.identyfikator_typu_return identyfikator_typu121 = null;

        pascalParser.identyfikator_typu_return identyfikator_typu122 = null;


        Object DWUKROPEK120_tree=null;
        RewriteRuleTokenStream stream_DWUKROPEK=new RewriteRuleTokenStream(adaptor,"token DWUKROPEK");
        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        RewriteRuleSubtreeStream stream_identyfikator_typu=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator_typu");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:189:5: ( identyfikator DWUKROPEK identyfikator_typu -> ^( VARIANT_TAG identyfikator identyfikator_typu ) | identyfikator_typu -> ^( VARIANT_TAG_NO_ID identyfikator_typu ) )
            int alt20=2;
            int LA20_0 = input.LA(1);

            if ( (LA20_0==IDENT) ) {
                int LA20_1 = input.LA(2);

                if ( (LA20_1==DWUKROPEK) ) {
                    alt20=1;
                }
                else if ( (LA20_1==OF) ) {
                    alt20=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 20, 1, input);

                    throw nvae;
                }
            }
            else if ( ((LA20_0>=CHAR && LA20_0<=STRING)) ) {
                alt20=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;
            }
            switch (alt20) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:190:2: identyfikator DWUKROPEK identyfikator_typu
                    {
                    pushFollow(FOLLOW_identyfikator_in_selektor_wariantu1248);
                    identyfikator119=identyfikator();

                    state._fsp--;

                    stream_identyfikator.add(identyfikator119.getTree());
                    DWUKROPEK120=(Token)match(input,DWUKROPEK,FOLLOW_DWUKROPEK_in_selektor_wariantu1250);  
                    stream_DWUKROPEK.add(DWUKROPEK120);

                    pushFollow(FOLLOW_identyfikator_typu_in_selektor_wariantu1252);
                    identyfikator_typu121=identyfikator_typu();

                    state._fsp--;

                    stream_identyfikator_typu.add(identyfikator_typu121.getTree());


                    // AST REWRITE
                    // elements: identyfikator, identyfikator_typu
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 190:46: -> ^( VARIANT_TAG identyfikator identyfikator_typu )
                    {
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:190:49: ^( VARIANT_TAG identyfikator identyfikator_typu )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(VARIANT_TAG, "VARIANT_TAG"), root_1);

                        adaptor.addChild(root_1, stream_identyfikator.nextTree());
                        adaptor.addChild(root_1, stream_identyfikator_typu.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:191:7: identyfikator_typu
                    {
                    pushFollow(FOLLOW_identyfikator_typu_in_selektor_wariantu1271);
                    identyfikator_typu122=identyfikator_typu();

                    state._fsp--;

                    stream_identyfikator_typu.add(identyfikator_typu122.getTree());


                    // AST REWRITE
                    // elements: identyfikator_typu
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 191:26: -> ^( VARIANT_TAG_NO_ID identyfikator_typu )
                    {
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:191:29: ^( VARIANT_TAG_NO_ID identyfikator_typu )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(VARIANT_TAG_NO_ID, "VARIANT_TAG_NO_ID"), root_1);

                        adaptor.addChild(root_1, stream_identyfikator_typu.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "selektor_wariantu"

    public static class wariant_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "wariant"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:194:1: wariant : lista_stalych_wyboru DWUKROPEK LNAWIAS lista_pol PNAWIAS -> ^( VARIANT_CASE lista_stalych_wyboru lista_pol ) ;
    public final pascalParser.wariant_return wariant() throws RecognitionException {
        pascalParser.wariant_return retval = new pascalParser.wariant_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token DWUKROPEK124=null;
        Token LNAWIAS125=null;
        Token PNAWIAS127=null;
        pascalParser.lista_stalych_wyboru_return lista_stalych_wyboru123 = null;

        pascalParser.lista_pol_return lista_pol126 = null;


        Object DWUKROPEK124_tree=null;
        Object LNAWIAS125_tree=null;
        Object PNAWIAS127_tree=null;
        RewriteRuleTokenStream stream_LNAWIAS=new RewriteRuleTokenStream(adaptor,"token LNAWIAS");
        RewriteRuleTokenStream stream_DWUKROPEK=new RewriteRuleTokenStream(adaptor,"token DWUKROPEK");
        RewriteRuleTokenStream stream_PNAWIAS=new RewriteRuleTokenStream(adaptor,"token PNAWIAS");
        RewriteRuleSubtreeStream stream_lista_stalych_wyboru=new RewriteRuleSubtreeStream(adaptor,"rule lista_stalych_wyboru");
        RewriteRuleSubtreeStream stream_lista_pol=new RewriteRuleSubtreeStream(adaptor,"rule lista_pol");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:195:5: ( lista_stalych_wyboru DWUKROPEK LNAWIAS lista_pol PNAWIAS -> ^( VARIANT_CASE lista_stalych_wyboru lista_pol ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:195:7: lista_stalych_wyboru DWUKROPEK LNAWIAS lista_pol PNAWIAS
            {
            pushFollow(FOLLOW_lista_stalych_wyboru_in_wariant1296);
            lista_stalych_wyboru123=lista_stalych_wyboru();

            state._fsp--;

            stream_lista_stalych_wyboru.add(lista_stalych_wyboru123.getTree());
            DWUKROPEK124=(Token)match(input,DWUKROPEK,FOLLOW_DWUKROPEK_in_wariant1298);  
            stream_DWUKROPEK.add(DWUKROPEK124);

            LNAWIAS125=(Token)match(input,LNAWIAS,FOLLOW_LNAWIAS_in_wariant1300);  
            stream_LNAWIAS.add(LNAWIAS125);

            pushFollow(FOLLOW_lista_pol_in_wariant1302);
            lista_pol126=lista_pol();

            state._fsp--;

            stream_lista_pol.add(lista_pol126.getTree());
            PNAWIAS127=(Token)match(input,PNAWIAS,FOLLOW_PNAWIAS_in_wariant1304);  
            stream_PNAWIAS.add(PNAWIAS127);



            // AST REWRITE
            // elements: lista_stalych_wyboru, lista_pol
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 195:64: -> ^( VARIANT_CASE lista_stalych_wyboru lista_pol )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:195:67: ^( VARIANT_CASE lista_stalych_wyboru lista_pol )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(VARIANT_CASE, "VARIANT_CASE"), root_1);

                adaptor.addChild(root_1, stream_lista_stalych_wyboru.nextTree());
                adaptor.addChild(root_1, stream_lista_pol.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "wariant"

    public static class nowy_typ_wskaznikowy_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "nowy_typ_wskaznikowy"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:198:1: nowy_typ_wskaznikowy : WSKAZNIK identyfikator_typu -> ^( WSKAZNIK identyfikator_typu ) ;
    public final pascalParser.nowy_typ_wskaznikowy_return nowy_typ_wskaznikowy() throws RecognitionException {
        pascalParser.nowy_typ_wskaznikowy_return retval = new pascalParser.nowy_typ_wskaznikowy_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token WSKAZNIK128=null;
        pascalParser.identyfikator_typu_return identyfikator_typu129 = null;


        Object WSKAZNIK128_tree=null;
        RewriteRuleTokenStream stream_WSKAZNIK=new RewriteRuleTokenStream(adaptor,"token WSKAZNIK");
        RewriteRuleSubtreeStream stream_identyfikator_typu=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator_typu");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:199:5: ( WSKAZNIK identyfikator_typu -> ^( WSKAZNIK identyfikator_typu ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:199:7: WSKAZNIK identyfikator_typu
            {
            WSKAZNIK128=(Token)match(input,WSKAZNIK,FOLLOW_WSKAZNIK_in_nowy_typ_wskaznikowy1331);  
            stream_WSKAZNIK.add(WSKAZNIK128);

            pushFollow(FOLLOW_identyfikator_typu_in_nowy_typ_wskaznikowy1333);
            identyfikator_typu129=identyfikator_typu();

            state._fsp--;

            stream_identyfikator_typu.add(identyfikator_typu129.getTree());


            // AST REWRITE
            // elements: WSKAZNIK, identyfikator_typu
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 199:35: -> ^( WSKAZNIK identyfikator_typu )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:199:38: ^( WSKAZNIK identyfikator_typu )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_WSKAZNIK.nextNode(), root_1);

                adaptor.addChild(root_1, stream_identyfikator_typu.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "nowy_typ_wskaznikowy"

    public static class czesc_deklarujaca_zmienne_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "czesc_deklarujaca_zmienne"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:202:1: czesc_deklarujaca_zmienne : VAR deklaracja_zmiennej ( SREDNIK deklaracja_zmiennej )* SREDNIK -> ^( VAR ( deklaracja_zmiennej )+ ) ;
    public final pascalParser.czesc_deklarujaca_zmienne_return czesc_deklarujaca_zmienne() throws RecognitionException {
        pascalParser.czesc_deklarujaca_zmienne_return retval = new pascalParser.czesc_deklarujaca_zmienne_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token VAR130=null;
        Token SREDNIK132=null;
        Token SREDNIK134=null;
        pascalParser.deklaracja_zmiennej_return deklaracja_zmiennej131 = null;

        pascalParser.deklaracja_zmiennej_return deklaracja_zmiennej133 = null;


        Object VAR130_tree=null;
        Object SREDNIK132_tree=null;
        Object SREDNIK134_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleTokenStream stream_VAR=new RewriteRuleTokenStream(adaptor,"token VAR");
        RewriteRuleSubtreeStream stream_deklaracja_zmiennej=new RewriteRuleSubtreeStream(adaptor,"rule deklaracja_zmiennej");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:203:5: ( VAR deklaracja_zmiennej ( SREDNIK deklaracja_zmiennej )* SREDNIK -> ^( VAR ( deklaracja_zmiennej )+ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:203:7: VAR deklaracja_zmiennej ( SREDNIK deklaracja_zmiennej )* SREDNIK
            {
            VAR130=(Token)match(input,VAR,FOLLOW_VAR_in_czesc_deklarujaca_zmienne1358);  
            stream_VAR.add(VAR130);

            pushFollow(FOLLOW_deklaracja_zmiennej_in_czesc_deklarujaca_zmienne1360);
            deklaracja_zmiennej131=deklaracja_zmiennej();

            state._fsp--;

            stream_deklaracja_zmiennej.add(deklaracja_zmiennej131.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:203:31: ( SREDNIK deklaracja_zmiennej )*
            loop21:
            do {
                int alt21=2;
                int LA21_0 = input.LA(1);

                if ( (LA21_0==SREDNIK) ) {
                    int LA21_1 = input.LA(2);

                    if ( (LA21_1==IDENT) ) {
                        alt21=1;
                    }


                }


                switch (alt21) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:203:33: SREDNIK deklaracja_zmiennej
            	    {
            	    SREDNIK132=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_deklarujaca_zmienne1364);  
            	    stream_SREDNIK.add(SREDNIK132);

            	    pushFollow(FOLLOW_deklaracja_zmiennej_in_czesc_deklarujaca_zmienne1366);
            	    deklaracja_zmiennej133=deklaracja_zmiennej();

            	    state._fsp--;

            	    stream_deklaracja_zmiennej.add(deklaracja_zmiennej133.getTree());

            	    }
            	    break;

            	default :
            	    break loop21;
                }
            } while (true);

            SREDNIK134=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_deklarujaca_zmienne1371);  
            stream_SREDNIK.add(SREDNIK134);



            // AST REWRITE
            // elements: VAR, deklaracja_zmiennej
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 203:72: -> ^( VAR ( deklaracja_zmiennej )+ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:203:75: ^( VAR ( deklaracja_zmiennej )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_VAR.nextNode(), root_1);

                if ( !(stream_deklaracja_zmiennej.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_deklaracja_zmiennej.hasNext() ) {
                    adaptor.addChild(root_1, stream_deklaracja_zmiennej.nextTree());

                }
                stream_deklaracja_zmiennej.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "czesc_deklarujaca_zmienne"

    public static class deklaracja_zmiennej_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "deklaracja_zmiennej"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:206:1: deklaracja_zmiennej : lista_identyfikatorow DWUKROPEK nowy_typ -> ^( VARDECL nowy_typ lista_identyfikatorow ) ;
    public final pascalParser.deklaracja_zmiennej_return deklaracja_zmiennej() throws RecognitionException {
        pascalParser.deklaracja_zmiennej_return retval = new pascalParser.deklaracja_zmiennej_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token DWUKROPEK136=null;
        pascalParser.lista_identyfikatorow_return lista_identyfikatorow135 = null;

        pascalParser.nowy_typ_return nowy_typ137 = null;


        Object DWUKROPEK136_tree=null;
        RewriteRuleTokenStream stream_DWUKROPEK=new RewriteRuleTokenStream(adaptor,"token DWUKROPEK");
        RewriteRuleSubtreeStream stream_nowy_typ=new RewriteRuleSubtreeStream(adaptor,"rule nowy_typ");
        RewriteRuleSubtreeStream stream_lista_identyfikatorow=new RewriteRuleSubtreeStream(adaptor,"rule lista_identyfikatorow");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:207:5: ( lista_identyfikatorow DWUKROPEK nowy_typ -> ^( VARDECL nowy_typ lista_identyfikatorow ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:207:7: lista_identyfikatorow DWUKROPEK nowy_typ
            {
            pushFollow(FOLLOW_lista_identyfikatorow_in_deklaracja_zmiennej1397);
            lista_identyfikatorow135=lista_identyfikatorow();

            state._fsp--;

            stream_lista_identyfikatorow.add(lista_identyfikatorow135.getTree());
            DWUKROPEK136=(Token)match(input,DWUKROPEK,FOLLOW_DWUKROPEK_in_deklaracja_zmiennej1399);  
            stream_DWUKROPEK.add(DWUKROPEK136);

            pushFollow(FOLLOW_nowy_typ_in_deklaracja_zmiennej1401);
            nowy_typ137=nowy_typ();

            state._fsp--;

            stream_nowy_typ.add(nowy_typ137.getTree());


            // AST REWRITE
            // elements: lista_identyfikatorow, nowy_typ
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 207:48: -> ^( VARDECL nowy_typ lista_identyfikatorow )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:207:51: ^( VARDECL nowy_typ lista_identyfikatorow )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(VARDECL, "VARDECL"), root_1);

                adaptor.addChild(root_1, stream_nowy_typ.nextTree());
                adaptor.addChild(root_1, stream_lista_identyfikatorow.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "deklaracja_zmiennej"

    public static class czesc_deklarujaca_procedury_i_funkcje_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "czesc_deklarujaca_procedury_i_funkcje"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:210:1: czesc_deklarujaca_procedury_i_funkcje : deklaracja_procedury_lub_funkcji SREDNIK ;
    public final pascalParser.czesc_deklarujaca_procedury_i_funkcje_return czesc_deklarujaca_procedury_i_funkcje() throws RecognitionException {
        pascalParser.czesc_deklarujaca_procedury_i_funkcje_return retval = new pascalParser.czesc_deklarujaca_procedury_i_funkcje_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token SREDNIK139=null;
        pascalParser.deklaracja_procedury_lub_funkcji_return deklaracja_procedury_lub_funkcji138 = null;


        Object SREDNIK139_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:211:5: ( deklaracja_procedury_lub_funkcji SREDNIK )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:211:7: deklaracja_procedury_lub_funkcji SREDNIK
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_deklaracja_procedury_lub_funkcji_in_czesc_deklarujaca_procedury_i_funkcje1428);
            deklaracja_procedury_lub_funkcji138=deklaracja_procedury_lub_funkcji();

            state._fsp--;

            adaptor.addChild(root_0, deklaracja_procedury_lub_funkcji138.getTree());
            SREDNIK139=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_czesc_deklarujaca_procedury_i_funkcje1430); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "czesc_deklarujaca_procedury_i_funkcje"

    public static class deklaracja_procedury_lub_funkcji_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "deklaracja_procedury_lub_funkcji"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:214:1: deklaracja_procedury_lub_funkcji : ( deklaracja_procedury | deklaracja_funkcji );
    public final pascalParser.deklaracja_procedury_lub_funkcji_return deklaracja_procedury_lub_funkcji() throws RecognitionException {
        pascalParser.deklaracja_procedury_lub_funkcji_return retval = new pascalParser.deklaracja_procedury_lub_funkcji_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.deklaracja_procedury_return deklaracja_procedury140 = null;

        pascalParser.deklaracja_funkcji_return deklaracja_funkcji141 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:215:5: ( deklaracja_procedury | deklaracja_funkcji )
            int alt22=2;
            int LA22_0 = input.LA(1);

            if ( (LA22_0==PROCEDURE) ) {
                alt22=1;
            }
            else if ( (LA22_0==FUNCTION) ) {
                alt22=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;
            }
            switch (alt22) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:215:7: deklaracja_procedury
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_deklaracja_procedury_in_deklaracja_procedury_lub_funkcji1448);
                    deklaracja_procedury140=deklaracja_procedury();

                    state._fsp--;

                    adaptor.addChild(root_0, deklaracja_procedury140.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:216:7: deklaracja_funkcji
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_deklaracja_funkcji_in_deklaracja_procedury_lub_funkcji1456);
                    deklaracja_funkcji141=deklaracja_funkcji();

                    state._fsp--;

                    adaptor.addChild(root_0, deklaracja_funkcji141.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "deklaracja_procedury_lub_funkcji"

    public static class deklaracja_procedury_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "deklaracja_procedury"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:219:1: deklaracja_procedury : PROCEDURE identyfikator ( lista_parametrow_formalnych )? SREDNIK blok -> ^( PROCEDURE identyfikator ( lista_parametrow_formalnych )? blok ) ;
    public final pascalParser.deklaracja_procedury_return deklaracja_procedury() throws RecognitionException {
        pascalParser.deklaracja_procedury_return retval = new pascalParser.deklaracja_procedury_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PROCEDURE142=null;
        Token SREDNIK145=null;
        pascalParser.identyfikator_return identyfikator143 = null;

        pascalParser.lista_parametrow_formalnych_return lista_parametrow_formalnych144 = null;

        pascalParser.blok_return blok146 = null;


        Object PROCEDURE142_tree=null;
        Object SREDNIK145_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleTokenStream stream_PROCEDURE=new RewriteRuleTokenStream(adaptor,"token PROCEDURE");
        RewriteRuleSubtreeStream stream_lista_parametrow_formalnych=new RewriteRuleSubtreeStream(adaptor,"rule lista_parametrow_formalnych");
        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        RewriteRuleSubtreeStream stream_blok=new RewriteRuleSubtreeStream(adaptor,"rule blok");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:220:5: ( PROCEDURE identyfikator ( lista_parametrow_formalnych )? SREDNIK blok -> ^( PROCEDURE identyfikator ( lista_parametrow_formalnych )? blok ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:220:7: PROCEDURE identyfikator ( lista_parametrow_formalnych )? SREDNIK blok
            {
            PROCEDURE142=(Token)match(input,PROCEDURE,FOLLOW_PROCEDURE_in_deklaracja_procedury1473);  
            stream_PROCEDURE.add(PROCEDURE142);

            pushFollow(FOLLOW_identyfikator_in_deklaracja_procedury1475);
            identyfikator143=identyfikator();

            state._fsp--;

            stream_identyfikator.add(identyfikator143.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:220:31: ( lista_parametrow_formalnych )?
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( (LA23_0==LNAWIAS) ) {
                alt23=1;
            }
            switch (alt23) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:220:32: lista_parametrow_formalnych
                    {
                    pushFollow(FOLLOW_lista_parametrow_formalnych_in_deklaracja_procedury1478);
                    lista_parametrow_formalnych144=lista_parametrow_formalnych();

                    state._fsp--;

                    stream_lista_parametrow_formalnych.add(lista_parametrow_formalnych144.getTree());

                    }
                    break;

            }

            SREDNIK145=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_deklaracja_procedury1482);  
            stream_SREDNIK.add(SREDNIK145);

            pushFollow(FOLLOW_blok_in_deklaracja_procedury1484);
            blok146=blok();

            state._fsp--;

            stream_blok.add(blok146.getTree());


            // AST REWRITE
            // elements: identyfikator, blok, PROCEDURE, lista_parametrow_formalnych
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 220:75: -> ^( PROCEDURE identyfikator ( lista_parametrow_formalnych )? blok )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:220:78: ^( PROCEDURE identyfikator ( lista_parametrow_formalnych )? blok )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_PROCEDURE.nextNode(), root_1);

                adaptor.addChild(root_1, stream_identyfikator.nextTree());
                // /home/ravn/Workspace/pascal4j/src/pascal.g:220:104: ( lista_parametrow_formalnych )?
                if ( stream_lista_parametrow_formalnych.hasNext() ) {
                    adaptor.addChild(root_1, stream_lista_parametrow_formalnych.nextTree());

                }
                stream_lista_parametrow_formalnych.reset();
                adaptor.addChild(root_1, stream_blok.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "deklaracja_procedury"

    public static class lista_parametrow_formalnych_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "lista_parametrow_formalnych"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:223:1: lista_parametrow_formalnych : LNAWIAS sekcja_parametrow_formalnych ( SREDNIK sekcja_parametrow_formalnych )* PNAWIAS -> ^( ARGDECLS ( sekcja_parametrow_formalnych )+ ) ;
    public final pascalParser.lista_parametrow_formalnych_return lista_parametrow_formalnych() throws RecognitionException {
        pascalParser.lista_parametrow_formalnych_return retval = new pascalParser.lista_parametrow_formalnych_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token LNAWIAS147=null;
        Token SREDNIK149=null;
        Token PNAWIAS151=null;
        pascalParser.sekcja_parametrow_formalnych_return sekcja_parametrow_formalnych148 = null;

        pascalParser.sekcja_parametrow_formalnych_return sekcja_parametrow_formalnych150 = null;


        Object LNAWIAS147_tree=null;
        Object SREDNIK149_tree=null;
        Object PNAWIAS151_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleTokenStream stream_LNAWIAS=new RewriteRuleTokenStream(adaptor,"token LNAWIAS");
        RewriteRuleTokenStream stream_PNAWIAS=new RewriteRuleTokenStream(adaptor,"token PNAWIAS");
        RewriteRuleSubtreeStream stream_sekcja_parametrow_formalnych=new RewriteRuleSubtreeStream(adaptor,"rule sekcja_parametrow_formalnych");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:224:5: ( LNAWIAS sekcja_parametrow_formalnych ( SREDNIK sekcja_parametrow_formalnych )* PNAWIAS -> ^( ARGDECLS ( sekcja_parametrow_formalnych )+ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:224:7: LNAWIAS sekcja_parametrow_formalnych ( SREDNIK sekcja_parametrow_formalnych )* PNAWIAS
            {
            LNAWIAS147=(Token)match(input,LNAWIAS,FOLLOW_LNAWIAS_in_lista_parametrow_formalnych1514);  
            stream_LNAWIAS.add(LNAWIAS147);

            pushFollow(FOLLOW_sekcja_parametrow_formalnych_in_lista_parametrow_formalnych1516);
            sekcja_parametrow_formalnych148=sekcja_parametrow_formalnych();

            state._fsp--;

            stream_sekcja_parametrow_formalnych.add(sekcja_parametrow_formalnych148.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:224:44: ( SREDNIK sekcja_parametrow_formalnych )*
            loop24:
            do {
                int alt24=2;
                int LA24_0 = input.LA(1);

                if ( (LA24_0==SREDNIK) ) {
                    alt24=1;
                }


                switch (alt24) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:224:46: SREDNIK sekcja_parametrow_formalnych
            	    {
            	    SREDNIK149=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_lista_parametrow_formalnych1520);  
            	    stream_SREDNIK.add(SREDNIK149);

            	    pushFollow(FOLLOW_sekcja_parametrow_formalnych_in_lista_parametrow_formalnych1522);
            	    sekcja_parametrow_formalnych150=sekcja_parametrow_formalnych();

            	    state._fsp--;

            	    stream_sekcja_parametrow_formalnych.add(sekcja_parametrow_formalnych150.getTree());

            	    }
            	    break;

            	default :
            	    break loop24;
                }
            } while (true);

            PNAWIAS151=(Token)match(input,PNAWIAS,FOLLOW_PNAWIAS_in_lista_parametrow_formalnych1527);  
            stream_PNAWIAS.add(PNAWIAS151);



            // AST REWRITE
            // elements: sekcja_parametrow_formalnych
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 224:94: -> ^( ARGDECLS ( sekcja_parametrow_formalnych )+ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:224:97: ^( ARGDECLS ( sekcja_parametrow_formalnych )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ARGDECLS, "ARGDECLS"), root_1);

                if ( !(stream_sekcja_parametrow_formalnych.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_sekcja_parametrow_formalnych.hasNext() ) {
                    adaptor.addChild(root_1, stream_sekcja_parametrow_formalnych.nextTree());

                }
                stream_sekcja_parametrow_formalnych.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "lista_parametrow_formalnych"

    public static class sekcja_parametrow_formalnych_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "sekcja_parametrow_formalnych"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:227:1: sekcja_parametrow_formalnych : ( grupa_parametrow | VAR grupa_parametrow );
    public final pascalParser.sekcja_parametrow_formalnych_return sekcja_parametrow_formalnych() throws RecognitionException {
        pascalParser.sekcja_parametrow_formalnych_return retval = new pascalParser.sekcja_parametrow_formalnych_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token VAR153=null;
        pascalParser.grupa_parametrow_return grupa_parametrow152 = null;

        pascalParser.grupa_parametrow_return grupa_parametrow154 = null;


        Object VAR153_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:228:5: ( grupa_parametrow | VAR grupa_parametrow )
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==IDENT) ) {
                alt25=1;
            }
            else if ( (LA25_0==VAR) ) {
                alt25=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;
            }
            switch (alt25) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:228:7: grupa_parametrow
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_grupa_parametrow_in_sekcja_parametrow_formalnych1553);
                    grupa_parametrow152=grupa_parametrow();

                    state._fsp--;

                    adaptor.addChild(root_0, grupa_parametrow152.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:229:7: VAR grupa_parametrow
                    {
                    root_0 = (Object)adaptor.nil();

                    VAR153=(Token)match(input,VAR,FOLLOW_VAR_in_sekcja_parametrow_formalnych1561); 
                    VAR153_tree = (Object)adaptor.create(VAR153);
                    root_0 = (Object)adaptor.becomeRoot(VAR153_tree, root_0);

                    pushFollow(FOLLOW_grupa_parametrow_in_sekcja_parametrow_formalnych1564);
                    grupa_parametrow154=grupa_parametrow();

                    state._fsp--;

                    adaptor.addChild(root_0, grupa_parametrow154.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "sekcja_parametrow_formalnych"

    public static class grupa_parametrow_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "grupa_parametrow"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:232:1: grupa_parametrow : lista_identyfikatorow DWUKROPEK identyfikator_typu -> ^( ARGDECL identyfikator_typu lista_identyfikatorow ) ;
    public final pascalParser.grupa_parametrow_return grupa_parametrow() throws RecognitionException {
        pascalParser.grupa_parametrow_return retval = new pascalParser.grupa_parametrow_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token DWUKROPEK156=null;
        pascalParser.lista_identyfikatorow_return lista_identyfikatorow155 = null;

        pascalParser.identyfikator_typu_return identyfikator_typu157 = null;


        Object DWUKROPEK156_tree=null;
        RewriteRuleTokenStream stream_DWUKROPEK=new RewriteRuleTokenStream(adaptor,"token DWUKROPEK");
        RewriteRuleSubtreeStream stream_lista_identyfikatorow=new RewriteRuleSubtreeStream(adaptor,"rule lista_identyfikatorow");
        RewriteRuleSubtreeStream stream_identyfikator_typu=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator_typu");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:233:5: ( lista_identyfikatorow DWUKROPEK identyfikator_typu -> ^( ARGDECL identyfikator_typu lista_identyfikatorow ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:233:7: lista_identyfikatorow DWUKROPEK identyfikator_typu
            {
            pushFollow(FOLLOW_lista_identyfikatorow_in_grupa_parametrow1582);
            lista_identyfikatorow155=lista_identyfikatorow();

            state._fsp--;

            stream_lista_identyfikatorow.add(lista_identyfikatorow155.getTree());
            DWUKROPEK156=(Token)match(input,DWUKROPEK,FOLLOW_DWUKROPEK_in_grupa_parametrow1584);  
            stream_DWUKROPEK.add(DWUKROPEK156);

            pushFollow(FOLLOW_identyfikator_typu_in_grupa_parametrow1586);
            identyfikator_typu157=identyfikator_typu();

            state._fsp--;

            stream_identyfikator_typu.add(identyfikator_typu157.getTree());


            // AST REWRITE
            // elements: identyfikator_typu, lista_identyfikatorow
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 233:58: -> ^( ARGDECL identyfikator_typu lista_identyfikatorow )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:233:61: ^( ARGDECL identyfikator_typu lista_identyfikatorow )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ARGDECL, "ARGDECL"), root_1);

                adaptor.addChild(root_1, stream_identyfikator_typu.nextTree());
                adaptor.addChild(root_1, stream_lista_identyfikatorow.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "grupa_parametrow"

    public static class lista_identyfikatorow_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "lista_identyfikatorow"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:236:1: lista_identyfikatorow : identyfikator ( PRZECINEK identyfikator )* -> ^( IDLIST ( identyfikator )+ ) ;
    public final pascalParser.lista_identyfikatorow_return lista_identyfikatorow() throws RecognitionException {
        pascalParser.lista_identyfikatorow_return retval = new pascalParser.lista_identyfikatorow_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PRZECINEK159=null;
        pascalParser.identyfikator_return identyfikator158 = null;

        pascalParser.identyfikator_return identyfikator160 = null;


        Object PRZECINEK159_tree=null;
        RewriteRuleTokenStream stream_PRZECINEK=new RewriteRuleTokenStream(adaptor,"token PRZECINEK");
        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:237:5: ( identyfikator ( PRZECINEK identyfikator )* -> ^( IDLIST ( identyfikator )+ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:237:7: identyfikator ( PRZECINEK identyfikator )*
            {
            pushFollow(FOLLOW_identyfikator_in_lista_identyfikatorow1613);
            identyfikator158=identyfikator();

            state._fsp--;

            stream_identyfikator.add(identyfikator158.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:237:21: ( PRZECINEK identyfikator )*
            loop26:
            do {
                int alt26=2;
                int LA26_0 = input.LA(1);

                if ( (LA26_0==PRZECINEK) ) {
                    alt26=1;
                }


                switch (alt26) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:237:23: PRZECINEK identyfikator
            	    {
            	    PRZECINEK159=(Token)match(input,PRZECINEK,FOLLOW_PRZECINEK_in_lista_identyfikatorow1617);  
            	    stream_PRZECINEK.add(PRZECINEK159);

            	    pushFollow(FOLLOW_identyfikator_in_lista_identyfikatorow1619);
            	    identyfikator160=identyfikator();

            	    state._fsp--;

            	    stream_identyfikator.add(identyfikator160.getTree());

            	    }
            	    break;

            	default :
            	    break loop26;
                }
            } while (true);



            // AST REWRITE
            // elements: identyfikator
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 237:50: -> ^( IDLIST ( identyfikator )+ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:237:53: ^( IDLIST ( identyfikator )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(IDLIST, "IDLIST"), root_1);

                if ( !(stream_identyfikator.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_identyfikator.hasNext() ) {
                    adaptor.addChild(root_1, stream_identyfikator.nextTree());

                }
                stream_identyfikator.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "lista_identyfikatorow"

    public static class lista_stalych_wyboru_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "lista_stalych_wyboru"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:240:1: lista_stalych_wyboru : stala ( PRZECINEK stala )* -> ^( CONSTLIST ( stala )+ ) ;
    public final pascalParser.lista_stalych_wyboru_return lista_stalych_wyboru() throws RecognitionException {
        pascalParser.lista_stalych_wyboru_return retval = new pascalParser.lista_stalych_wyboru_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PRZECINEK162=null;
        pascalParser.stala_return stala161 = null;

        pascalParser.stala_return stala163 = null;


        Object PRZECINEK162_tree=null;
        RewriteRuleTokenStream stream_PRZECINEK=new RewriteRuleTokenStream(adaptor,"token PRZECINEK");
        RewriteRuleSubtreeStream stream_stala=new RewriteRuleSubtreeStream(adaptor,"rule stala");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:241:5: ( stala ( PRZECINEK stala )* -> ^( CONSTLIST ( stala )+ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:241:7: stala ( PRZECINEK stala )*
            {
            pushFollow(FOLLOW_stala_in_lista_stalych_wyboru1648);
            stala161=stala();

            state._fsp--;

            stream_stala.add(stala161.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:241:13: ( PRZECINEK stala )*
            loop27:
            do {
                int alt27=2;
                int LA27_0 = input.LA(1);

                if ( (LA27_0==PRZECINEK) ) {
                    alt27=1;
                }


                switch (alt27) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:241:15: PRZECINEK stala
            	    {
            	    PRZECINEK162=(Token)match(input,PRZECINEK,FOLLOW_PRZECINEK_in_lista_stalych_wyboru1652);  
            	    stream_PRZECINEK.add(PRZECINEK162);

            	    pushFollow(FOLLOW_stala_in_lista_stalych_wyboru1654);
            	    stala163=stala();

            	    state._fsp--;

            	    stream_stala.add(stala163.getTree());

            	    }
            	    break;

            	default :
            	    break loop27;
                }
            } while (true);



            // AST REWRITE
            // elements: stala
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 241:34: -> ^( CONSTLIST ( stala )+ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:241:37: ^( CONSTLIST ( stala )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(CONSTLIST, "CONSTLIST"), root_1);

                if ( !(stream_stala.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_stala.hasNext() ) {
                    adaptor.addChild(root_1, stream_stala.nextTree());

                }
                stream_stala.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "lista_stalych_wyboru"

    public static class deklaracja_funkcji_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "deklaracja_funkcji"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:244:1: deklaracja_funkcji : FUNCTION identyfikator ( lista_parametrow_formalnych )? DWUKROPEK typ_wyniku SREDNIK blok -> ^( FUNCTION identyfikator ( lista_parametrow_formalnych )? typ_wyniku blok ) ;
    public final pascalParser.deklaracja_funkcji_return deklaracja_funkcji() throws RecognitionException {
        pascalParser.deklaracja_funkcji_return retval = new pascalParser.deklaracja_funkcji_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token FUNCTION164=null;
        Token DWUKROPEK167=null;
        Token SREDNIK169=null;
        pascalParser.identyfikator_return identyfikator165 = null;

        pascalParser.lista_parametrow_formalnych_return lista_parametrow_formalnych166 = null;

        pascalParser.typ_wyniku_return typ_wyniku168 = null;

        pascalParser.blok_return blok170 = null;


        Object FUNCTION164_tree=null;
        Object DWUKROPEK167_tree=null;
        Object SREDNIK169_tree=null;
        RewriteRuleTokenStream stream_FUNCTION=new RewriteRuleTokenStream(adaptor,"token FUNCTION");
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleTokenStream stream_DWUKROPEK=new RewriteRuleTokenStream(adaptor,"token DWUKROPEK");
        RewriteRuleSubtreeStream stream_lista_parametrow_formalnych=new RewriteRuleSubtreeStream(adaptor,"rule lista_parametrow_formalnych");
        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        RewriteRuleSubtreeStream stream_blok=new RewriteRuleSubtreeStream(adaptor,"rule blok");
        RewriteRuleSubtreeStream stream_typ_wyniku=new RewriteRuleSubtreeStream(adaptor,"rule typ_wyniku");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:245:5: ( FUNCTION identyfikator ( lista_parametrow_formalnych )? DWUKROPEK typ_wyniku SREDNIK blok -> ^( FUNCTION identyfikator ( lista_parametrow_formalnych )? typ_wyniku blok ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:245:7: FUNCTION identyfikator ( lista_parametrow_formalnych )? DWUKROPEK typ_wyniku SREDNIK blok
            {
            FUNCTION164=(Token)match(input,FUNCTION,FOLLOW_FUNCTION_in_deklaracja_funkcji1683);  
            stream_FUNCTION.add(FUNCTION164);

            pushFollow(FOLLOW_identyfikator_in_deklaracja_funkcji1685);
            identyfikator165=identyfikator();

            state._fsp--;

            stream_identyfikator.add(identyfikator165.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:245:30: ( lista_parametrow_formalnych )?
            int alt28=2;
            int LA28_0 = input.LA(1);

            if ( (LA28_0==LNAWIAS) ) {
                alt28=1;
            }
            switch (alt28) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:245:31: lista_parametrow_formalnych
                    {
                    pushFollow(FOLLOW_lista_parametrow_formalnych_in_deklaracja_funkcji1688);
                    lista_parametrow_formalnych166=lista_parametrow_formalnych();

                    state._fsp--;

                    stream_lista_parametrow_formalnych.add(lista_parametrow_formalnych166.getTree());

                    }
                    break;

            }

            DWUKROPEK167=(Token)match(input,DWUKROPEK,FOLLOW_DWUKROPEK_in_deklaracja_funkcji1692);  
            stream_DWUKROPEK.add(DWUKROPEK167);

            pushFollow(FOLLOW_typ_wyniku_in_deklaracja_funkcji1694);
            typ_wyniku168=typ_wyniku();

            state._fsp--;

            stream_typ_wyniku.add(typ_wyniku168.getTree());
            SREDNIK169=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_deklaracja_funkcji1696);  
            stream_SREDNIK.add(SREDNIK169);

            pushFollow(FOLLOW_blok_in_deklaracja_funkcji1699);
            blok170=blok();

            state._fsp--;

            stream_blok.add(blok170.getTree());


            // AST REWRITE
            // elements: blok, lista_parametrow_formalnych, FUNCTION, typ_wyniku, identyfikator
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 245:96: -> ^( FUNCTION identyfikator ( lista_parametrow_formalnych )? typ_wyniku blok )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:245:99: ^( FUNCTION identyfikator ( lista_parametrow_formalnych )? typ_wyniku blok )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_FUNCTION.nextNode(), root_1);

                adaptor.addChild(root_1, stream_identyfikator.nextTree());
                // /home/ravn/Workspace/pascal4j/src/pascal.g:245:124: ( lista_parametrow_formalnych )?
                if ( stream_lista_parametrow_formalnych.hasNext() ) {
                    adaptor.addChild(root_1, stream_lista_parametrow_formalnych.nextTree());

                }
                stream_lista_parametrow_formalnych.reset();
                adaptor.addChild(root_1, stream_typ_wyniku.nextTree());
                adaptor.addChild(root_1, stream_blok.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "deklaracja_funkcji"

    public static class typ_wyniku_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typ_wyniku"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:248:1: typ_wyniku : identyfikator_typu ;
    public final pascalParser.typ_wyniku_return typ_wyniku() throws RecognitionException {
        pascalParser.typ_wyniku_return retval = new pascalParser.typ_wyniku_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.identyfikator_typu_return identyfikator_typu171 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:249:5: ( identyfikator_typu )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:249:7: identyfikator_typu
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_identyfikator_typu_in_typ_wyniku1731);
            identyfikator_typu171=identyfikator_typu();

            state._fsp--;

            adaptor.addChild(root_0, identyfikator_typu171.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "typ_wyniku"

    public static class instrukcja_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:252:1: instrukcja : ( etykieta DWUKROPEK instrukcja_bez_etykiety -> ^( DWUKROPEK etykieta instrukcja_bez_etykiety ) | instrukcja_bez_etykiety );
    public final pascalParser.instrukcja_return instrukcja() throws RecognitionException {
        pascalParser.instrukcja_return retval = new pascalParser.instrukcja_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token DWUKROPEK173=null;
        pascalParser.etykieta_return etykieta172 = null;

        pascalParser.instrukcja_bez_etykiety_return instrukcja_bez_etykiety174 = null;

        pascalParser.instrukcja_bez_etykiety_return instrukcja_bez_etykiety175 = null;


        Object DWUKROPEK173_tree=null;
        RewriteRuleTokenStream stream_DWUKROPEK=new RewriteRuleTokenStream(adaptor,"token DWUKROPEK");
        RewriteRuleSubtreeStream stream_instrukcja_bez_etykiety=new RewriteRuleSubtreeStream(adaptor,"rule instrukcja_bez_etykiety");
        RewriteRuleSubtreeStream stream_etykieta=new RewriteRuleSubtreeStream(adaptor,"rule etykieta");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:253:5: ( etykieta DWUKROPEK instrukcja_bez_etykiety -> ^( DWUKROPEK etykieta instrukcja_bez_etykiety ) | instrukcja_bez_etykiety )
            int alt29=2;
            int LA29_0 = input.LA(1);

            if ( (LA29_0==NUM_INT) ) {
                alt29=1;
            }
            else if ( ((LA29_0>=SREDNIK && LA29_0<=IDENT)||LA29_0==END||LA29_0==CASE||(LA29_0>=GOTO && LA29_0<=IF)||(LA29_0>=ELSE && LA29_0<=WHILE)||(LA29_0>=REPEAT && LA29_0<=FOR)||LA29_0==WITH) ) {
                alt29=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 29, 0, input);

                throw nvae;
            }
            switch (alt29) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:253:7: etykieta DWUKROPEK instrukcja_bez_etykiety
                    {
                    pushFollow(FOLLOW_etykieta_in_instrukcja1748);
                    etykieta172=etykieta();

                    state._fsp--;

                    stream_etykieta.add(etykieta172.getTree());
                    DWUKROPEK173=(Token)match(input,DWUKROPEK,FOLLOW_DWUKROPEK_in_instrukcja1750);  
                    stream_DWUKROPEK.add(DWUKROPEK173);

                    pushFollow(FOLLOW_instrukcja_bez_etykiety_in_instrukcja1752);
                    instrukcja_bez_etykiety174=instrukcja_bez_etykiety();

                    state._fsp--;

                    stream_instrukcja_bez_etykiety.add(instrukcja_bez_etykiety174.getTree());


                    // AST REWRITE
                    // elements: DWUKROPEK, instrukcja_bez_etykiety, etykieta
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 253:50: -> ^( DWUKROPEK etykieta instrukcja_bez_etykiety )
                    {
                        // /home/ravn/Workspace/pascal4j/src/pascal.g:253:53: ^( DWUKROPEK etykieta instrukcja_bez_etykiety )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(stream_DWUKROPEK.nextNode(), root_1);

                        adaptor.addChild(root_1, stream_etykieta.nextTree());
                        adaptor.addChild(root_1, stream_instrukcja_bez_etykiety.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:254:7: instrukcja_bez_etykiety
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_bez_etykiety_in_instrukcja1770);
                    instrukcja_bez_etykiety175=instrukcja_bez_etykiety();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_bez_etykiety175.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja"

    public static class instrukcja_bez_etykiety_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_bez_etykiety"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:257:1: instrukcja_bez_etykiety : ( instrukcja_prosta | instrukcja_strukturalna );
    public final pascalParser.instrukcja_bez_etykiety_return instrukcja_bez_etykiety() throws RecognitionException {
        pascalParser.instrukcja_bez_etykiety_return retval = new pascalParser.instrukcja_bez_etykiety_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.instrukcja_prosta_return instrukcja_prosta176 = null;

        pascalParser.instrukcja_strukturalna_return instrukcja_strukturalna177 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:258:5: ( instrukcja_prosta | instrukcja_strukturalna )
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( ((LA30_0>=SREDNIK && LA30_0<=IDENT)||LA30_0==END||LA30_0==GOTO||LA30_0==ELSE||LA30_0==UNTIL) ) {
                alt30=1;
            }
            else if ( (LA30_0==CASE||(LA30_0>=BEGIN && LA30_0<=IF)||LA30_0==WHILE||LA30_0==REPEAT||LA30_0==FOR||LA30_0==WITH) ) {
                alt30=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;
            }
            switch (alt30) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:258:7: instrukcja_prosta
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_prosta_in_instrukcja_bez_etykiety1787);
                    instrukcja_prosta176=instrukcja_prosta();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_prosta176.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:259:7: instrukcja_strukturalna
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_strukturalna_in_instrukcja_bez_etykiety1795);
                    instrukcja_strukturalna177=instrukcja_strukturalna();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_strukturalna177.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_bez_etykiety"

    public static class instrukcja_prosta_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_prosta"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:262:1: instrukcja_prosta : ( instrukcja_przypisania | instrukcja_procedury | instrukcja_skoku | instrukcja_pusta );
    public final pascalParser.instrukcja_prosta_return instrukcja_prosta() throws RecognitionException {
        pascalParser.instrukcja_prosta_return retval = new pascalParser.instrukcja_prosta_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.instrukcja_przypisania_return instrukcja_przypisania178 = null;

        pascalParser.instrukcja_procedury_return instrukcja_procedury179 = null;

        pascalParser.instrukcja_skoku_return instrukcja_skoku180 = null;

        pascalParser.instrukcja_pusta_return instrukcja_pusta181 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:263:5: ( instrukcja_przypisania | instrukcja_procedury | instrukcja_skoku | instrukcja_pusta )
            int alt31=4;
            switch ( input.LA(1) ) {
            case IDENT:
                {
                int LA31_1 = input.LA(2);

                if ( (LA31_1==LNAWIAS||LA31_1==SREDNIK||LA31_1==END||LA31_1==ELSE||LA31_1==UNTIL) ) {
                    alt31=2;
                }
                else if ( (LA31_1==KROPKA||LA31_1==LNAWIASKWADRATOWY||LA31_1==LNAWIAS2||LA31_1==WSKAZNIK||LA31_1==PRZYPISANIE) ) {
                    alt31=1;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 1, input);

                    throw nvae;
                }
                }
                break;
            case GOTO:
                {
                alt31=3;
                }
                break;
            case SREDNIK:
            case END:
            case ELSE:
            case UNTIL:
                {
                alt31=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 31, 0, input);

                throw nvae;
            }

            switch (alt31) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:263:7: instrukcja_przypisania
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_przypisania_in_instrukcja_prosta1812);
                    instrukcja_przypisania178=instrukcja_przypisania();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_przypisania178.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:264:7: instrukcja_procedury
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_procedury_in_instrukcja_prosta1820);
                    instrukcja_procedury179=instrukcja_procedury();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_procedury179.getTree());

                    }
                    break;
                case 3 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:265:7: instrukcja_skoku
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_skoku_in_instrukcja_prosta1828);
                    instrukcja_skoku180=instrukcja_skoku();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_skoku180.getTree());

                    }
                    break;
                case 4 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:266:7: instrukcja_pusta
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_pusta_in_instrukcja_prosta1836);
                    instrukcja_pusta181=instrukcja_pusta();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_pusta181.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_prosta"

    public static class instrukcja_przypisania_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_przypisania"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:269:1: instrukcja_przypisania : zmienna PRZYPISANIE wyrazenie -> ^( PRZYPISANIE zmienna wyrazenie ) ;
    public final pascalParser.instrukcja_przypisania_return instrukcja_przypisania() throws RecognitionException {
        pascalParser.instrukcja_przypisania_return retval = new pascalParser.instrukcja_przypisania_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PRZYPISANIE183=null;
        pascalParser.zmienna_return zmienna182 = null;

        pascalParser.wyrazenie_return wyrazenie184 = null;


        Object PRZYPISANIE183_tree=null;
        RewriteRuleTokenStream stream_PRZYPISANIE=new RewriteRuleTokenStream(adaptor,"token PRZYPISANIE");
        RewriteRuleSubtreeStream stream_zmienna=new RewriteRuleSubtreeStream(adaptor,"rule zmienna");
        RewriteRuleSubtreeStream stream_wyrazenie=new RewriteRuleSubtreeStream(adaptor,"rule wyrazenie");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:270:5: ( zmienna PRZYPISANIE wyrazenie -> ^( PRZYPISANIE zmienna wyrazenie ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:270:7: zmienna PRZYPISANIE wyrazenie
            {
            pushFollow(FOLLOW_zmienna_in_instrukcja_przypisania1853);
            zmienna182=zmienna();

            state._fsp--;

            stream_zmienna.add(zmienna182.getTree());
            PRZYPISANIE183=(Token)match(input,PRZYPISANIE,FOLLOW_PRZYPISANIE_in_instrukcja_przypisania1855);  
            stream_PRZYPISANIE.add(PRZYPISANIE183);

            pushFollow(FOLLOW_wyrazenie_in_instrukcja_przypisania1857);
            wyrazenie184=wyrazenie();

            state._fsp--;

            stream_wyrazenie.add(wyrazenie184.getTree());


            // AST REWRITE
            // elements: wyrazenie, zmienna, PRZYPISANIE
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 270:37: -> ^( PRZYPISANIE zmienna wyrazenie )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:270:40: ^( PRZYPISANIE zmienna wyrazenie )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_PRZYPISANIE.nextNode(), root_1);

                adaptor.addChild(root_1, stream_zmienna.nextTree());
                adaptor.addChild(root_1, stream_wyrazenie.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_przypisania"

    public static class zmienna_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "zmienna"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:276:1: zmienna : identyfikator ( LNAWIASKWADRATOWY wyrazenie ( PRZECINEK wyrazenie )* PNAWIASKWADRATOWY | LNAWIAS2 wyrazenie ( PRZECINEK wyrazenie )* PNAWIAS2 | KROPKA identyfikator | WSKAZNIK )* ;
    public final pascalParser.zmienna_return zmienna() throws RecognitionException {
        pascalParser.zmienna_return retval = new pascalParser.zmienna_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token LNAWIASKWADRATOWY186=null;
        Token PRZECINEK188=null;
        Token PNAWIASKWADRATOWY190=null;
        Token LNAWIAS2191=null;
        Token PRZECINEK193=null;
        Token PNAWIAS2195=null;
        Token KROPKA196=null;
        Token WSKAZNIK198=null;
        pascalParser.identyfikator_return identyfikator185 = null;

        pascalParser.wyrazenie_return wyrazenie187 = null;

        pascalParser.wyrazenie_return wyrazenie189 = null;

        pascalParser.wyrazenie_return wyrazenie192 = null;

        pascalParser.wyrazenie_return wyrazenie194 = null;

        pascalParser.identyfikator_return identyfikator197 = null;


        Object LNAWIASKWADRATOWY186_tree=null;
        Object PRZECINEK188_tree=null;
        Object PNAWIASKWADRATOWY190_tree=null;
        Object LNAWIAS2191_tree=null;
        Object PRZECINEK193_tree=null;
        Object PNAWIAS2195_tree=null;
        Object KROPKA196_tree=null;
        Object WSKAZNIK198_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:277:5: ( identyfikator ( LNAWIASKWADRATOWY wyrazenie ( PRZECINEK wyrazenie )* PNAWIASKWADRATOWY | LNAWIAS2 wyrazenie ( PRZECINEK wyrazenie )* PNAWIAS2 | KROPKA identyfikator | WSKAZNIK )* )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:277:8: identyfikator ( LNAWIASKWADRATOWY wyrazenie ( PRZECINEK wyrazenie )* PNAWIASKWADRATOWY | LNAWIAS2 wyrazenie ( PRZECINEK wyrazenie )* PNAWIAS2 | KROPKA identyfikator | WSKAZNIK )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_identyfikator_in_zmienna1887);
            identyfikator185=identyfikator();

            state._fsp--;

            adaptor.addChild(root_0, identyfikator185.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:278:7: ( LNAWIASKWADRATOWY wyrazenie ( PRZECINEK wyrazenie )* PNAWIASKWADRATOWY | LNAWIAS2 wyrazenie ( PRZECINEK wyrazenie )* PNAWIAS2 | KROPKA identyfikator | WSKAZNIK )*
            loop34:
            do {
                int alt34=5;
                switch ( input.LA(1) ) {
                case LNAWIASKWADRATOWY:
                    {
                    alt34=1;
                    }
                    break;
                case LNAWIAS2:
                    {
                    alt34=2;
                    }
                    break;
                case KROPKA:
                    {
                    alt34=3;
                    }
                    break;
                case WSKAZNIK:
                    {
                    alt34=4;
                    }
                    break;

                }

                switch (alt34) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:278:9: LNAWIASKWADRATOWY wyrazenie ( PRZECINEK wyrazenie )* PNAWIASKWADRATOWY
            	    {
            	    LNAWIASKWADRATOWY186=(Token)match(input,LNAWIASKWADRATOWY,FOLLOW_LNAWIASKWADRATOWY_in_zmienna1897); 
            	    LNAWIASKWADRATOWY186_tree = (Object)adaptor.create(LNAWIASKWADRATOWY186);
            	    root_0 = (Object)adaptor.becomeRoot(LNAWIASKWADRATOWY186_tree, root_0);

            	    pushFollow(FOLLOW_wyrazenie_in_zmienna1900);
            	    wyrazenie187=wyrazenie();

            	    state._fsp--;

            	    adaptor.addChild(root_0, wyrazenie187.getTree());
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:278:38: ( PRZECINEK wyrazenie )*
            	    loop32:
            	    do {
            	        int alt32=2;
            	        int LA32_0 = input.LA(1);

            	        if ( (LA32_0==PRZECINEK) ) {
            	            alt32=1;
            	        }


            	        switch (alt32) {
            	    	case 1 :
            	    	    // /home/ravn/Workspace/pascal4j/src/pascal.g:278:40: PRZECINEK wyrazenie
            	    	    {
            	    	    PRZECINEK188=(Token)match(input,PRZECINEK,FOLLOW_PRZECINEK_in_zmienna1904); 
            	    	    pushFollow(FOLLOW_wyrazenie_in_zmienna1907);
            	    	    wyrazenie189=wyrazenie();

            	    	    state._fsp--;

            	    	    adaptor.addChild(root_0, wyrazenie189.getTree());

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop32;
            	        }
            	    } while (true);

            	    PNAWIASKWADRATOWY190=(Token)match(input,PNAWIASKWADRATOWY,FOLLOW_PNAWIASKWADRATOWY_in_zmienna1911); 

            	    }
            	    break;
            	case 2 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:279:9: LNAWIAS2 wyrazenie ( PRZECINEK wyrazenie )* PNAWIAS2
            	    {
            	    LNAWIAS2191=(Token)match(input,LNAWIAS2,FOLLOW_LNAWIAS2_in_zmienna1922); 
            	    LNAWIAS2191_tree = (Object)adaptor.create(LNAWIAS2191);
            	    root_0 = (Object)adaptor.becomeRoot(LNAWIAS2191_tree, root_0);

            	    pushFollow(FOLLOW_wyrazenie_in_zmienna1925);
            	    wyrazenie192=wyrazenie();

            	    state._fsp--;

            	    adaptor.addChild(root_0, wyrazenie192.getTree());
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:279:29: ( PRZECINEK wyrazenie )*
            	    loop33:
            	    do {
            	        int alt33=2;
            	        int LA33_0 = input.LA(1);

            	        if ( (LA33_0==PRZECINEK) ) {
            	            alt33=1;
            	        }


            	        switch (alt33) {
            	    	case 1 :
            	    	    // /home/ravn/Workspace/pascal4j/src/pascal.g:279:31: PRZECINEK wyrazenie
            	    	    {
            	    	    PRZECINEK193=(Token)match(input,PRZECINEK,FOLLOW_PRZECINEK_in_zmienna1929); 
            	    	    pushFollow(FOLLOW_wyrazenie_in_zmienna1932);
            	    	    wyrazenie194=wyrazenie();

            	    	    state._fsp--;

            	    	    adaptor.addChild(root_0, wyrazenie194.getTree());

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop33;
            	        }
            	    } while (true);

            	    PNAWIAS2195=(Token)match(input,PNAWIAS2,FOLLOW_PNAWIAS2_in_zmienna1936); 

            	    }
            	    break;
            	case 3 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:280:9: KROPKA identyfikator
            	    {
            	    KROPKA196=(Token)match(input,KROPKA,FOLLOW_KROPKA_in_zmienna1947); 
            	    KROPKA196_tree = (Object)adaptor.create(KROPKA196);
            	    root_0 = (Object)adaptor.becomeRoot(KROPKA196_tree, root_0);

            	    pushFollow(FOLLOW_identyfikator_in_zmienna1950);
            	    identyfikator197=identyfikator();

            	    state._fsp--;

            	    adaptor.addChild(root_0, identyfikator197.getTree());

            	    }
            	    break;
            	case 4 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:281:9: WSKAZNIK
            	    {
            	    WSKAZNIK198=(Token)match(input,WSKAZNIK,FOLLOW_WSKAZNIK_in_zmienna1960); 
            	    WSKAZNIK198_tree = (Object)adaptor.create(WSKAZNIK198);
            	    root_0 = (Object)adaptor.becomeRoot(WSKAZNIK198_tree, root_0);


            	    }
            	    break;

            	default :
            	    break loop34;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "zmienna"

    public static class wyrazenie_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "wyrazenie"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:285:1: wyrazenie : proste_wyrazenie ( ( ROWNOSC | NIEROWNOSC | MNIEJSZY | MNIEJSZYLUBROWNY | WIEKSZYLUBROWNY | WIEKSZY | IN ) proste_wyrazenie )* ;
    public final pascalParser.wyrazenie_return wyrazenie() throws RecognitionException {
        pascalParser.wyrazenie_return retval = new pascalParser.wyrazenie_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token ROWNOSC200=null;
        Token NIEROWNOSC201=null;
        Token MNIEJSZY202=null;
        Token MNIEJSZYLUBROWNY203=null;
        Token WIEKSZYLUBROWNY204=null;
        Token WIEKSZY205=null;
        Token IN206=null;
        pascalParser.proste_wyrazenie_return proste_wyrazenie199 = null;

        pascalParser.proste_wyrazenie_return proste_wyrazenie207 = null;


        Object ROWNOSC200_tree=null;
        Object NIEROWNOSC201_tree=null;
        Object MNIEJSZY202_tree=null;
        Object MNIEJSZYLUBROWNY203_tree=null;
        Object WIEKSZYLUBROWNY204_tree=null;
        Object WIEKSZY205_tree=null;
        Object IN206_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:286:5: ( proste_wyrazenie ( ( ROWNOSC | NIEROWNOSC | MNIEJSZY | MNIEJSZYLUBROWNY | WIEKSZYLUBROWNY | WIEKSZY | IN ) proste_wyrazenie )* )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:286:7: proste_wyrazenie ( ( ROWNOSC | NIEROWNOSC | MNIEJSZY | MNIEJSZYLUBROWNY | WIEKSZYLUBROWNY | WIEKSZY | IN ) proste_wyrazenie )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_proste_wyrazenie_in_wyrazenie1987);
            proste_wyrazenie199=proste_wyrazenie();

            state._fsp--;

            adaptor.addChild(root_0, proste_wyrazenie199.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:287:4: ( ( ROWNOSC | NIEROWNOSC | MNIEJSZY | MNIEJSZYLUBROWNY | WIEKSZYLUBROWNY | WIEKSZY | IN ) proste_wyrazenie )*
            loop36:
            do {
                int alt36=2;
                int LA36_0 = input.LA(1);

                if ( (LA36_0==ROWNOSC||(LA36_0>=NIEROWNOSC && LA36_0<=IN)) ) {
                    alt36=1;
                }


                switch (alt36) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:287:6: ( ROWNOSC | NIEROWNOSC | MNIEJSZY | MNIEJSZYLUBROWNY | WIEKSZYLUBROWNY | WIEKSZY | IN ) proste_wyrazenie
            	    {
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:287:6: ( ROWNOSC | NIEROWNOSC | MNIEJSZY | MNIEJSZYLUBROWNY | WIEKSZYLUBROWNY | WIEKSZY | IN )
            	    int alt35=7;
            	    switch ( input.LA(1) ) {
            	    case ROWNOSC:
            	        {
            	        alt35=1;
            	        }
            	        break;
            	    case NIEROWNOSC:
            	        {
            	        alt35=2;
            	        }
            	        break;
            	    case MNIEJSZY:
            	        {
            	        alt35=3;
            	        }
            	        break;
            	    case MNIEJSZYLUBROWNY:
            	        {
            	        alt35=4;
            	        }
            	        break;
            	    case WIEKSZYLUBROWNY:
            	        {
            	        alt35=5;
            	        }
            	        break;
            	    case WIEKSZY:
            	        {
            	        alt35=6;
            	        }
            	        break;
            	    case IN:
            	        {
            	        alt35=7;
            	        }
            	        break;
            	    default:
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 35, 0, input);

            	        throw nvae;
            	    }

            	    switch (alt35) {
            	        case 1 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:287:7: ROWNOSC
            	            {
            	            ROWNOSC200=(Token)match(input,ROWNOSC,FOLLOW_ROWNOSC_in_wyrazenie1995); 
            	            ROWNOSC200_tree = (Object)adaptor.create(ROWNOSC200);
            	            root_0 = (Object)adaptor.becomeRoot(ROWNOSC200_tree, root_0);


            	            }
            	            break;
            	        case 2 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:287:18: NIEROWNOSC
            	            {
            	            NIEROWNOSC201=(Token)match(input,NIEROWNOSC,FOLLOW_NIEROWNOSC_in_wyrazenie2000); 
            	            NIEROWNOSC201_tree = (Object)adaptor.create(NIEROWNOSC201);
            	            root_0 = (Object)adaptor.becomeRoot(NIEROWNOSC201_tree, root_0);


            	            }
            	            break;
            	        case 3 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:287:32: MNIEJSZY
            	            {
            	            MNIEJSZY202=(Token)match(input,MNIEJSZY,FOLLOW_MNIEJSZY_in_wyrazenie2005); 
            	            MNIEJSZY202_tree = (Object)adaptor.create(MNIEJSZY202);
            	            root_0 = (Object)adaptor.becomeRoot(MNIEJSZY202_tree, root_0);


            	            }
            	            break;
            	        case 4 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:287:44: MNIEJSZYLUBROWNY
            	            {
            	            MNIEJSZYLUBROWNY203=(Token)match(input,MNIEJSZYLUBROWNY,FOLLOW_MNIEJSZYLUBROWNY_in_wyrazenie2010); 
            	            MNIEJSZYLUBROWNY203_tree = (Object)adaptor.create(MNIEJSZYLUBROWNY203);
            	            root_0 = (Object)adaptor.becomeRoot(MNIEJSZYLUBROWNY203_tree, root_0);


            	            }
            	            break;
            	        case 5 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:287:64: WIEKSZYLUBROWNY
            	            {
            	            WIEKSZYLUBROWNY204=(Token)match(input,WIEKSZYLUBROWNY,FOLLOW_WIEKSZYLUBROWNY_in_wyrazenie2015); 
            	            WIEKSZYLUBROWNY204_tree = (Object)adaptor.create(WIEKSZYLUBROWNY204);
            	            root_0 = (Object)adaptor.becomeRoot(WIEKSZYLUBROWNY204_tree, root_0);


            	            }
            	            break;
            	        case 6 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:287:83: WIEKSZY
            	            {
            	            WIEKSZY205=(Token)match(input,WIEKSZY,FOLLOW_WIEKSZY_in_wyrazenie2020); 
            	            WIEKSZY205_tree = (Object)adaptor.create(WIEKSZY205);
            	            root_0 = (Object)adaptor.becomeRoot(WIEKSZY205_tree, root_0);


            	            }
            	            break;
            	        case 7 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:287:94: IN
            	            {
            	            IN206=(Token)match(input,IN,FOLLOW_IN_in_wyrazenie2025); 
            	            IN206_tree = (Object)adaptor.create(IN206);
            	            root_0 = (Object)adaptor.becomeRoot(IN206_tree, root_0);


            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_proste_wyrazenie_in_wyrazenie2029);
            	    proste_wyrazenie207=proste_wyrazenie();

            	    state._fsp--;

            	    adaptor.addChild(root_0, proste_wyrazenie207.getTree());

            	    }
            	    break;

            	default :
            	    break loop36;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "wyrazenie"

    public static class proste_wyrazenie_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "proste_wyrazenie"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:290:1: proste_wyrazenie : skladnik ( ( PLUS | MINUS | OR ) skladnik )* ;
    public final pascalParser.proste_wyrazenie_return proste_wyrazenie() throws RecognitionException {
        pascalParser.proste_wyrazenie_return retval = new pascalParser.proste_wyrazenie_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PLUS209=null;
        Token MINUS210=null;
        Token OR211=null;
        pascalParser.skladnik_return skladnik208 = null;

        pascalParser.skladnik_return skladnik212 = null;


        Object PLUS209_tree=null;
        Object MINUS210_tree=null;
        Object OR211_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:291:5: ( skladnik ( ( PLUS | MINUS | OR ) skladnik )* )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:291:7: skladnik ( ( PLUS | MINUS | OR ) skladnik )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_skladnik_in_proste_wyrazenie2049);
            skladnik208=skladnik();

            state._fsp--;

            adaptor.addChild(root_0, skladnik208.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:291:16: ( ( PLUS | MINUS | OR ) skladnik )*
            loop38:
            do {
                int alt38=2;
                int LA38_0 = input.LA(1);

                if ( ((LA38_0>=PLUS && LA38_0<=MINUS)||LA38_0==OR) ) {
                    alt38=1;
                }


                switch (alt38) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:291:18: ( PLUS | MINUS | OR ) skladnik
            	    {
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:291:18: ( PLUS | MINUS | OR )
            	    int alt37=3;
            	    switch ( input.LA(1) ) {
            	    case PLUS:
            	        {
            	        alt37=1;
            	        }
            	        break;
            	    case MINUS:
            	        {
            	        alt37=2;
            	        }
            	        break;
            	    case OR:
            	        {
            	        alt37=3;
            	        }
            	        break;
            	    default:
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 37, 0, input);

            	        throw nvae;
            	    }

            	    switch (alt37) {
            	        case 1 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:291:19: PLUS
            	            {
            	            PLUS209=(Token)match(input,PLUS,FOLLOW_PLUS_in_proste_wyrazenie2054); 
            	            PLUS209_tree = (Object)adaptor.create(PLUS209);
            	            root_0 = (Object)adaptor.becomeRoot(PLUS209_tree, root_0);


            	            }
            	            break;
            	        case 2 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:291:27: MINUS
            	            {
            	            MINUS210=(Token)match(input,MINUS,FOLLOW_MINUS_in_proste_wyrazenie2059); 
            	            MINUS210_tree = (Object)adaptor.create(MINUS210);
            	            root_0 = (Object)adaptor.becomeRoot(MINUS210_tree, root_0);


            	            }
            	            break;
            	        case 3 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:291:36: OR
            	            {
            	            OR211=(Token)match(input,OR,FOLLOW_OR_in_proste_wyrazenie2064); 
            	            OR211_tree = (Object)adaptor.create(OR211);
            	            root_0 = (Object)adaptor.becomeRoot(OR211_tree, root_0);


            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_skladnik_in_proste_wyrazenie2068);
            	    skladnik212=skladnik();

            	    state._fsp--;

            	    adaptor.addChild(root_0, skladnik212.getTree());

            	    }
            	    break;

            	default :
            	    break loop38;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "proste_wyrazenie"

    public static class skladnik_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "skladnik"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:294:1: skladnik : czynnik ( ( GWIAZDKA | SLASH | DIV | MOD | AND ) czynnik )* ;
    public final pascalParser.skladnik_return skladnik() throws RecognitionException {
        pascalParser.skladnik_return retval = new pascalParser.skladnik_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token GWIAZDKA214=null;
        Token SLASH215=null;
        Token DIV216=null;
        Token MOD217=null;
        Token AND218=null;
        pascalParser.czynnik_return czynnik213 = null;

        pascalParser.czynnik_return czynnik219 = null;


        Object GWIAZDKA214_tree=null;
        Object SLASH215_tree=null;
        Object DIV216_tree=null;
        Object MOD217_tree=null;
        Object AND218_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:295:2: ( czynnik ( ( GWIAZDKA | SLASH | DIV | MOD | AND ) czynnik )* )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:295:4: czynnik ( ( GWIAZDKA | SLASH | DIV | MOD | AND ) czynnik )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_czynnik_in_skladnik2085);
            czynnik213=czynnik();

            state._fsp--;

            adaptor.addChild(root_0, czynnik213.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:295:12: ( ( GWIAZDKA | SLASH | DIV | MOD | AND ) czynnik )*
            loop40:
            do {
                int alt40=2;
                int LA40_0 = input.LA(1);

                if ( ((LA40_0>=GWIAZDKA && LA40_0<=AND)) ) {
                    alt40=1;
                }


                switch (alt40) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:295:14: ( GWIAZDKA | SLASH | DIV | MOD | AND ) czynnik
            	    {
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:295:14: ( GWIAZDKA | SLASH | DIV | MOD | AND )
            	    int alt39=5;
            	    switch ( input.LA(1) ) {
            	    case GWIAZDKA:
            	        {
            	        alt39=1;
            	        }
            	        break;
            	    case SLASH:
            	        {
            	        alt39=2;
            	        }
            	        break;
            	    case DIV:
            	        {
            	        alt39=3;
            	        }
            	        break;
            	    case MOD:
            	        {
            	        alt39=4;
            	        }
            	        break;
            	    case AND:
            	        {
            	        alt39=5;
            	        }
            	        break;
            	    default:
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 39, 0, input);

            	        throw nvae;
            	    }

            	    switch (alt39) {
            	        case 1 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:295:15: GWIAZDKA
            	            {
            	            GWIAZDKA214=(Token)match(input,GWIAZDKA,FOLLOW_GWIAZDKA_in_skladnik2090); 
            	            GWIAZDKA214_tree = (Object)adaptor.create(GWIAZDKA214);
            	            root_0 = (Object)adaptor.becomeRoot(GWIAZDKA214_tree, root_0);


            	            }
            	            break;
            	        case 2 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:295:27: SLASH
            	            {
            	            SLASH215=(Token)match(input,SLASH,FOLLOW_SLASH_in_skladnik2095); 
            	            SLASH215_tree = (Object)adaptor.create(SLASH215);
            	            root_0 = (Object)adaptor.becomeRoot(SLASH215_tree, root_0);


            	            }
            	            break;
            	        case 3 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:295:36: DIV
            	            {
            	            DIV216=(Token)match(input,DIV,FOLLOW_DIV_in_skladnik2100); 
            	            DIV216_tree = (Object)adaptor.create(DIV216);
            	            root_0 = (Object)adaptor.becomeRoot(DIV216_tree, root_0);


            	            }
            	            break;
            	        case 4 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:295:43: MOD
            	            {
            	            MOD217=(Token)match(input,MOD,FOLLOW_MOD_in_skladnik2105); 
            	            MOD217_tree = (Object)adaptor.create(MOD217);
            	            root_0 = (Object)adaptor.becomeRoot(MOD217_tree, root_0);


            	            }
            	            break;
            	        case 5 :
            	            // /home/ravn/Workspace/pascal4j/src/pascal.g:295:50: AND
            	            {
            	            AND218=(Token)match(input,AND,FOLLOW_AND_in_skladnik2110); 
            	            AND218_tree = (Object)adaptor.create(AND218);
            	            root_0 = (Object)adaptor.becomeRoot(AND218_tree, root_0);


            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_czynnik_in_skladnik2114);
            	    czynnik219=czynnik();

            	    state._fsp--;

            	    adaptor.addChild(root_0, czynnik219.getTree());

            	    }
            	    break;

            	default :
            	    break loop40;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "skladnik"

    public static class czynnik_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "czynnik"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:298:1: czynnik : ( PLUS | MINUS )? czynnik_bez_znaku ;
    public final pascalParser.czynnik_return czynnik() throws RecognitionException {
        pascalParser.czynnik_return retval = new pascalParser.czynnik_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PLUS220=null;
        Token MINUS221=null;
        pascalParser.czynnik_bez_znaku_return czynnik_bez_znaku222 = null;


        Object PLUS220_tree=null;
        Object MINUS221_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:299:5: ( ( PLUS | MINUS )? czynnik_bez_znaku )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:299:7: ( PLUS | MINUS )? czynnik_bez_znaku
            {
            root_0 = (Object)adaptor.nil();

            // /home/ravn/Workspace/pascal4j/src/pascal.g:299:7: ( PLUS | MINUS )?
            int alt41=3;
            int LA41_0 = input.LA(1);

            if ( (LA41_0==PLUS) ) {
                alt41=1;
            }
            else if ( (LA41_0==MINUS) ) {
                alt41=2;
            }
            switch (alt41) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:299:8: PLUS
                    {
                    PLUS220=(Token)match(input,PLUS,FOLLOW_PLUS_in_czynnik2135); 
                    PLUS220_tree = (Object)adaptor.create(PLUS220);
                    root_0 = (Object)adaptor.becomeRoot(PLUS220_tree, root_0);


                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:299:14: MINUS
                    {
                    MINUS221=(Token)match(input,MINUS,FOLLOW_MINUS_in_czynnik2138); 
                    MINUS221_tree = (Object)adaptor.create(MINUS221);
                    root_0 = (Object)adaptor.becomeRoot(MINUS221_tree, root_0);


                    }
                    break;

            }

            pushFollow(FOLLOW_czynnik_bez_znaku_in_czynnik2143);
            czynnik_bez_znaku222=czynnik_bez_znaku();

            state._fsp--;

            adaptor.addChild(root_0, czynnik_bez_znaku222.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "czynnik"

    public static class czynnik_bez_znaku_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "czynnik_bez_znaku"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:302:1: czynnik_bez_znaku : ( zmienna | LNAWIAS wyrazenie PNAWIAS | nazewnik_funkcji | stala_bez_znaku | NOT czynnik_bez_znaku );
    public final pascalParser.czynnik_bez_znaku_return czynnik_bez_znaku() throws RecognitionException {
        pascalParser.czynnik_bez_znaku_return retval = new pascalParser.czynnik_bez_znaku_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token LNAWIAS224=null;
        Token PNAWIAS226=null;
        Token NOT229=null;
        pascalParser.zmienna_return zmienna223 = null;

        pascalParser.wyrazenie_return wyrazenie225 = null;

        pascalParser.nazewnik_funkcji_return nazewnik_funkcji227 = null;

        pascalParser.stala_bez_znaku_return stala_bez_znaku228 = null;

        pascalParser.czynnik_bez_znaku_return czynnik_bez_znaku230 = null;


        Object LNAWIAS224_tree=null;
        Object PNAWIAS226_tree=null;
        Object NOT229_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:303:5: ( zmienna | LNAWIAS wyrazenie PNAWIAS | nazewnik_funkcji | stala_bez_znaku | NOT czynnik_bez_znaku )
            int alt42=5;
            switch ( input.LA(1) ) {
            case IDENT:
                {
                int LA42_1 = input.LA(2);

                if ( (LA42_1==LNAWIAS) ) {
                    alt42=3;
                }
                else if ( (LA42_1==KROPKA||(LA42_1>=PNAWIAS && LA42_1<=SREDNIK)||LA42_1==PRZECINEK||LA42_1==ROWNOSC||(LA42_1>=PLUS && LA42_1<=MINUS)||(LA42_1>=LNAWIASKWADRATOWY && LA42_1<=PNAWIAS2)||LA42_1==END||LA42_1==WSKAZNIK||(LA42_1>=NIEROWNOSC && LA42_1<=AND)||(LA42_1>=THEN && LA42_1<=ELSE)||LA42_1==DO||LA42_1==UNTIL||(LA42_1>=TO && LA42_1<=DOWNTO)) ) {
                    alt42=1;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 1, input);

                    throw nvae;
                }
                }
                break;
            case LNAWIAS:
                {
                alt42=2;
                }
                break;
            case NUM_INT:
            case NUM_REAL:
            case STRING_LITERAL:
            case NIL:
                {
                alt42=4;
                }
                break;
            case NOT:
                {
                alt42=5;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 42, 0, input);

                throw nvae;
            }

            switch (alt42) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:303:7: zmienna
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_zmienna_in_czynnik_bez_znaku2160);
                    zmienna223=zmienna();

                    state._fsp--;

                    adaptor.addChild(root_0, zmienna223.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:304:7: LNAWIAS wyrazenie PNAWIAS
                    {
                    root_0 = (Object)adaptor.nil();

                    LNAWIAS224=(Token)match(input,LNAWIAS,FOLLOW_LNAWIAS_in_czynnik_bez_znaku2168); 
                    pushFollow(FOLLOW_wyrazenie_in_czynnik_bez_znaku2171);
                    wyrazenie225=wyrazenie();

                    state._fsp--;

                    adaptor.addChild(root_0, wyrazenie225.getTree());
                    PNAWIAS226=(Token)match(input,PNAWIAS,FOLLOW_PNAWIAS_in_czynnik_bez_znaku2173); 

                    }
                    break;
                case 3 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:305:7: nazewnik_funkcji
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_nazewnik_funkcji_in_czynnik_bez_znaku2182);
                    nazewnik_funkcji227=nazewnik_funkcji();

                    state._fsp--;

                    adaptor.addChild(root_0, nazewnik_funkcji227.getTree());

                    }
                    break;
                case 4 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:306:7: stala_bez_znaku
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_stala_bez_znaku_in_czynnik_bez_znaku2190);
                    stala_bez_znaku228=stala_bez_znaku();

                    state._fsp--;

                    adaptor.addChild(root_0, stala_bez_znaku228.getTree());

                    }
                    break;
                case 5 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:307:7: NOT czynnik_bez_znaku
                    {
                    root_0 = (Object)adaptor.nil();

                    NOT229=(Token)match(input,NOT,FOLLOW_NOT_in_czynnik_bez_znaku2198); 
                    NOT229_tree = (Object)adaptor.create(NOT229);
                    root_0 = (Object)adaptor.becomeRoot(NOT229_tree, root_0);

                    pushFollow(FOLLOW_czynnik_bez_znaku_in_czynnik_bez_znaku2201);
                    czynnik_bez_znaku230=czynnik_bez_znaku();

                    state._fsp--;

                    adaptor.addChild(root_0, czynnik_bez_znaku230.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "czynnik_bez_znaku"

    public static class stala_bez_znaku_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "stala_bez_znaku"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:310:1: stala_bez_znaku : ( liczba_bez_znaku | napis | NIL );
    public final pascalParser.stala_bez_znaku_return stala_bez_znaku() throws RecognitionException {
        pascalParser.stala_bez_znaku_return retval = new pascalParser.stala_bez_znaku_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token NIL233=null;
        pascalParser.liczba_bez_znaku_return liczba_bez_znaku231 = null;

        pascalParser.napis_return napis232 = null;


        Object NIL233_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:311:5: ( liczba_bez_znaku | napis | NIL )
            int alt43=3;
            switch ( input.LA(1) ) {
            case NUM_INT:
            case NUM_REAL:
                {
                alt43=1;
                }
                break;
            case STRING_LITERAL:
                {
                alt43=2;
                }
                break;
            case NIL:
                {
                alt43=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 43, 0, input);

                throw nvae;
            }

            switch (alt43) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:311:7: liczba_bez_znaku
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_liczba_bez_znaku_in_stala_bez_znaku2218);
                    liczba_bez_znaku231=liczba_bez_znaku();

                    state._fsp--;

                    adaptor.addChild(root_0, liczba_bez_znaku231.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:312:7: napis
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_napis_in_stala_bez_znaku2226);
                    napis232=napis();

                    state._fsp--;

                    adaptor.addChild(root_0, napis232.getTree());

                    }
                    break;
                case 3 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:313:7: NIL
                    {
                    root_0 = (Object)adaptor.nil();

                    NIL233=(Token)match(input,NIL,FOLLOW_NIL_in_stala_bez_znaku2234); 
                    NIL233_tree = (Object)adaptor.create(NIL233);
                    adaptor.addChild(root_0, NIL233_tree);


                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "stala_bez_znaku"

    public static class nazewnik_funkcji_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "nazewnik_funkcji"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:316:1: nazewnik_funkcji : identyfikator LNAWIAS lista_parametrow_aktualnych PNAWIAS -> ^( FUNC_CALL identyfikator lista_parametrow_aktualnych ) ;
    public final pascalParser.nazewnik_funkcji_return nazewnik_funkcji() throws RecognitionException {
        pascalParser.nazewnik_funkcji_return retval = new pascalParser.nazewnik_funkcji_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token LNAWIAS235=null;
        Token PNAWIAS237=null;
        pascalParser.identyfikator_return identyfikator234 = null;

        pascalParser.lista_parametrow_aktualnych_return lista_parametrow_aktualnych236 = null;


        Object LNAWIAS235_tree=null;
        Object PNAWIAS237_tree=null;
        RewriteRuleTokenStream stream_LNAWIAS=new RewriteRuleTokenStream(adaptor,"token LNAWIAS");
        RewriteRuleTokenStream stream_PNAWIAS=new RewriteRuleTokenStream(adaptor,"token PNAWIAS");
        RewriteRuleSubtreeStream stream_lista_parametrow_aktualnych=new RewriteRuleSubtreeStream(adaptor,"rule lista_parametrow_aktualnych");
        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:317:5: ( identyfikator LNAWIAS lista_parametrow_aktualnych PNAWIAS -> ^( FUNC_CALL identyfikator lista_parametrow_aktualnych ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:317:7: identyfikator LNAWIAS lista_parametrow_aktualnych PNAWIAS
            {
            pushFollow(FOLLOW_identyfikator_in_nazewnik_funkcji2251);
            identyfikator234=identyfikator();

            state._fsp--;

            stream_identyfikator.add(identyfikator234.getTree());
            LNAWIAS235=(Token)match(input,LNAWIAS,FOLLOW_LNAWIAS_in_nazewnik_funkcji2253);  
            stream_LNAWIAS.add(LNAWIAS235);

            pushFollow(FOLLOW_lista_parametrow_aktualnych_in_nazewnik_funkcji2255);
            lista_parametrow_aktualnych236=lista_parametrow_aktualnych();

            state._fsp--;

            stream_lista_parametrow_aktualnych.add(lista_parametrow_aktualnych236.getTree());
            PNAWIAS237=(Token)match(input,PNAWIAS,FOLLOW_PNAWIAS_in_nazewnik_funkcji2257);  
            stream_PNAWIAS.add(PNAWIAS237);



            // AST REWRITE
            // elements: identyfikator, lista_parametrow_aktualnych
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 317:65: -> ^( FUNC_CALL identyfikator lista_parametrow_aktualnych )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:317:68: ^( FUNC_CALL identyfikator lista_parametrow_aktualnych )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FUNC_CALL, "FUNC_CALL"), root_1);

                adaptor.addChild(root_1, stream_identyfikator.nextTree());
                adaptor.addChild(root_1, stream_lista_parametrow_aktualnych.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "nazewnik_funkcji"

    public static class lista_parametrow_aktualnych_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "lista_parametrow_aktualnych"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:320:1: lista_parametrow_aktualnych : parametr_aktualny ( PRZECINEK parametr_aktualny )* -> ^( ARGLIST ( parametr_aktualny )+ ) ;
    public final pascalParser.lista_parametrow_aktualnych_return lista_parametrow_aktualnych() throws RecognitionException {
        pascalParser.lista_parametrow_aktualnych_return retval = new pascalParser.lista_parametrow_aktualnych_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PRZECINEK239=null;
        pascalParser.parametr_aktualny_return parametr_aktualny238 = null;

        pascalParser.parametr_aktualny_return parametr_aktualny240 = null;


        Object PRZECINEK239_tree=null;
        RewriteRuleTokenStream stream_PRZECINEK=new RewriteRuleTokenStream(adaptor,"token PRZECINEK");
        RewriteRuleSubtreeStream stream_parametr_aktualny=new RewriteRuleSubtreeStream(adaptor,"rule parametr_aktualny");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:321:5: ( parametr_aktualny ( PRZECINEK parametr_aktualny )* -> ^( ARGLIST ( parametr_aktualny )+ ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:321:7: parametr_aktualny ( PRZECINEK parametr_aktualny )*
            {
            pushFollow(FOLLOW_parametr_aktualny_in_lista_parametrow_aktualnych2284);
            parametr_aktualny238=parametr_aktualny();

            state._fsp--;

            stream_parametr_aktualny.add(parametr_aktualny238.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:321:25: ( PRZECINEK parametr_aktualny )*
            loop44:
            do {
                int alt44=2;
                int LA44_0 = input.LA(1);

                if ( (LA44_0==PRZECINEK) ) {
                    alt44=1;
                }


                switch (alt44) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:321:27: PRZECINEK parametr_aktualny
            	    {
            	    PRZECINEK239=(Token)match(input,PRZECINEK,FOLLOW_PRZECINEK_in_lista_parametrow_aktualnych2288);  
            	    stream_PRZECINEK.add(PRZECINEK239);

            	    pushFollow(FOLLOW_parametr_aktualny_in_lista_parametrow_aktualnych2290);
            	    parametr_aktualny240=parametr_aktualny();

            	    state._fsp--;

            	    stream_parametr_aktualny.add(parametr_aktualny240.getTree());

            	    }
            	    break;

            	default :
            	    break loop44;
                }
            } while (true);



            // AST REWRITE
            // elements: parametr_aktualny
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 321:58: -> ^( ARGLIST ( parametr_aktualny )+ )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:321:61: ^( ARGLIST ( parametr_aktualny )+ )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ARGLIST, "ARGLIST"), root_1);

                if ( !(stream_parametr_aktualny.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_parametr_aktualny.hasNext() ) {
                    adaptor.addChild(root_1, stream_parametr_aktualny.nextTree());

                }
                stream_parametr_aktualny.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "lista_parametrow_aktualnych"

    public static class instrukcja_procedury_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_procedury"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:324:1: instrukcja_procedury : identyfikator ( LNAWIAS lista_parametrow_aktualnych PNAWIAS )? -> ^( PROC_CALL identyfikator ( lista_parametrow_aktualnych )? ) ;
    public final pascalParser.instrukcja_procedury_return instrukcja_procedury() throws RecognitionException {
        pascalParser.instrukcja_procedury_return retval = new pascalParser.instrukcja_procedury_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token LNAWIAS242=null;
        Token PNAWIAS244=null;
        pascalParser.identyfikator_return identyfikator241 = null;

        pascalParser.lista_parametrow_aktualnych_return lista_parametrow_aktualnych243 = null;


        Object LNAWIAS242_tree=null;
        Object PNAWIAS244_tree=null;
        RewriteRuleTokenStream stream_LNAWIAS=new RewriteRuleTokenStream(adaptor,"token LNAWIAS");
        RewriteRuleTokenStream stream_PNAWIAS=new RewriteRuleTokenStream(adaptor,"token PNAWIAS");
        RewriteRuleSubtreeStream stream_lista_parametrow_aktualnych=new RewriteRuleSubtreeStream(adaptor,"rule lista_parametrow_aktualnych");
        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:325:5: ( identyfikator ( LNAWIAS lista_parametrow_aktualnych PNAWIAS )? -> ^( PROC_CALL identyfikator ( lista_parametrow_aktualnych )? ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:325:7: identyfikator ( LNAWIAS lista_parametrow_aktualnych PNAWIAS )?
            {
            pushFollow(FOLLOW_identyfikator_in_instrukcja_procedury2323);
            identyfikator241=identyfikator();

            state._fsp--;

            stream_identyfikator.add(identyfikator241.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:325:21: ( LNAWIAS lista_parametrow_aktualnych PNAWIAS )?
            int alt45=2;
            int LA45_0 = input.LA(1);

            if ( (LA45_0==LNAWIAS) ) {
                alt45=1;
            }
            switch (alt45) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:325:23: LNAWIAS lista_parametrow_aktualnych PNAWIAS
                    {
                    LNAWIAS242=(Token)match(input,LNAWIAS,FOLLOW_LNAWIAS_in_instrukcja_procedury2327);  
                    stream_LNAWIAS.add(LNAWIAS242);

                    pushFollow(FOLLOW_lista_parametrow_aktualnych_in_instrukcja_procedury2329);
                    lista_parametrow_aktualnych243=lista_parametrow_aktualnych();

                    state._fsp--;

                    stream_lista_parametrow_aktualnych.add(lista_parametrow_aktualnych243.getTree());
                    PNAWIAS244=(Token)match(input,PNAWIAS,FOLLOW_PNAWIAS_in_instrukcja_procedury2331);  
                    stream_PNAWIAS.add(PNAWIAS244);


                    }
                    break;

            }



            // AST REWRITE
            // elements: lista_parametrow_aktualnych, identyfikator
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 325:70: -> ^( PROC_CALL identyfikator ( lista_parametrow_aktualnych )? )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:325:73: ^( PROC_CALL identyfikator ( lista_parametrow_aktualnych )? )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PROC_CALL, "PROC_CALL"), root_1);

                adaptor.addChild(root_1, stream_identyfikator.nextTree());
                // /home/ravn/Workspace/pascal4j/src/pascal.g:325:99: ( lista_parametrow_aktualnych )?
                if ( stream_lista_parametrow_aktualnych.hasNext() ) {
                    adaptor.addChild(root_1, stream_lista_parametrow_aktualnych.nextTree());

                }
                stream_lista_parametrow_aktualnych.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_procedury"

    public static class parametr_aktualny_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parametr_aktualny"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:328:1: parametr_aktualny : wyrazenie ;
    public final pascalParser.parametr_aktualny_return parametr_aktualny() throws RecognitionException {
        pascalParser.parametr_aktualny_return retval = new pascalParser.parametr_aktualny_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.wyrazenie_return wyrazenie245 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:329:5: ( wyrazenie )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:329:7: wyrazenie
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_wyrazenie_in_parametr_aktualny2362);
            wyrazenie245=wyrazenie();

            state._fsp--;

            adaptor.addChild(root_0, wyrazenie245.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "parametr_aktualny"

    public static class instrukcja_skoku_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_skoku"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:332:1: instrukcja_skoku : GOTO etykieta ;
    public final pascalParser.instrukcja_skoku_return instrukcja_skoku() throws RecognitionException {
        pascalParser.instrukcja_skoku_return retval = new pascalParser.instrukcja_skoku_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token GOTO246=null;
        pascalParser.etykieta_return etykieta247 = null;


        Object GOTO246_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:333:5: ( GOTO etykieta )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:333:7: GOTO etykieta
            {
            root_0 = (Object)adaptor.nil();

            GOTO246=(Token)match(input,GOTO,FOLLOW_GOTO_in_instrukcja_skoku2379); 
            GOTO246_tree = (Object)adaptor.create(GOTO246);
            root_0 = (Object)adaptor.becomeRoot(GOTO246_tree, root_0);

            pushFollow(FOLLOW_etykieta_in_instrukcja_skoku2382);
            etykieta247=etykieta();

            state._fsp--;

            adaptor.addChild(root_0, etykieta247.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_skoku"

    public static class instrukcja_pusta_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_pusta"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:336:1: instrukcja_pusta : ;
    public final pascalParser.instrukcja_pusta_return instrukcja_pusta() throws RecognitionException {
        pascalParser.instrukcja_pusta_return retval = new pascalParser.instrukcja_pusta_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:337:5: ()
            // /home/ravn/Workspace/pascal4j/src/pascal.g:338:5: 
            {
            root_0 = (Object)adaptor.nil();

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_pusta"

    public static class instrukcja_strukturalna_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_strukturalna"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:340:1: instrukcja_strukturalna : ( instrukcja_zlozona | instrukcja_warunkowa | instrukcja_iteracyjna | instrukcja_wiazaca );
    public final pascalParser.instrukcja_strukturalna_return instrukcja_strukturalna() throws RecognitionException {
        pascalParser.instrukcja_strukturalna_return retval = new pascalParser.instrukcja_strukturalna_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.instrukcja_zlozona_return instrukcja_zlozona248 = null;

        pascalParser.instrukcja_warunkowa_return instrukcja_warunkowa249 = null;

        pascalParser.instrukcja_iteracyjna_return instrukcja_iteracyjna250 = null;

        pascalParser.instrukcja_wiazaca_return instrukcja_wiazaca251 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:341:5: ( instrukcja_zlozona | instrukcja_warunkowa | instrukcja_iteracyjna | instrukcja_wiazaca )
            int alt46=4;
            switch ( input.LA(1) ) {
            case BEGIN:
                {
                alt46=1;
                }
                break;
            case CASE:
            case IF:
                {
                alt46=2;
                }
                break;
            case WHILE:
            case REPEAT:
            case FOR:
                {
                alt46=3;
                }
                break;
            case WITH:
                {
                alt46=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 46, 0, input);

                throw nvae;
            }

            switch (alt46) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:341:7: instrukcja_zlozona
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_zlozona_in_instrukcja_strukturalna2414);
                    instrukcja_zlozona248=instrukcja_zlozona();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_zlozona248.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:342:7: instrukcja_warunkowa
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_warunkowa_in_instrukcja_strukturalna2422);
                    instrukcja_warunkowa249=instrukcja_warunkowa();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_warunkowa249.getTree());

                    }
                    break;
                case 3 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:343:7: instrukcja_iteracyjna
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_iteracyjna_in_instrukcja_strukturalna2430);
                    instrukcja_iteracyjna250=instrukcja_iteracyjna();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_iteracyjna250.getTree());

                    }
                    break;
                case 4 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:344:7: instrukcja_wiazaca
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_wiazaca_in_instrukcja_strukturalna2438);
                    instrukcja_wiazaca251=instrukcja_wiazaca();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_wiazaca251.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_strukturalna"

    public static class instrukcja_zlozona_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_zlozona"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:347:1: instrukcja_zlozona : BEGIN ciag_instrukcji END ;
    public final pascalParser.instrukcja_zlozona_return instrukcja_zlozona() throws RecognitionException {
        pascalParser.instrukcja_zlozona_return retval = new pascalParser.instrukcja_zlozona_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token BEGIN252=null;
        Token END254=null;
        pascalParser.ciag_instrukcji_return ciag_instrukcji253 = null;


        Object BEGIN252_tree=null;
        Object END254_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:348:5: ( BEGIN ciag_instrukcji END )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:348:7: BEGIN ciag_instrukcji END
            {
            root_0 = (Object)adaptor.nil();

            BEGIN252=(Token)match(input,BEGIN,FOLLOW_BEGIN_in_instrukcja_zlozona2455); 
            pushFollow(FOLLOW_ciag_instrukcji_in_instrukcja_zlozona2460);
            ciag_instrukcji253=ciag_instrukcji();

            state._fsp--;

            adaptor.addChild(root_0, ciag_instrukcji253.getTree());
            END254=(Token)match(input,END,FOLLOW_END_in_instrukcja_zlozona2468); 

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_zlozona"

    public static class ciag_instrukcji_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "ciag_instrukcji"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:353:1: ciag_instrukcji : instrukcja ( SREDNIK instrukcja )* -> ^( BLOCK ( instrukcja )* ) ;
    public final pascalParser.ciag_instrukcji_return ciag_instrukcji() throws RecognitionException {
        pascalParser.ciag_instrukcji_return retval = new pascalParser.ciag_instrukcji_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token SREDNIK256=null;
        pascalParser.instrukcja_return instrukcja255 = null;

        pascalParser.instrukcja_return instrukcja257 = null;


        Object SREDNIK256_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleSubtreeStream stream_instrukcja=new RewriteRuleSubtreeStream(adaptor,"rule instrukcja");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:354:5: ( instrukcja ( SREDNIK instrukcja )* -> ^( BLOCK ( instrukcja )* ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:354:7: instrukcja ( SREDNIK instrukcja )*
            {
            pushFollow(FOLLOW_instrukcja_in_ciag_instrukcji2486);
            instrukcja255=instrukcja();

            state._fsp--;

            stream_instrukcja.add(instrukcja255.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:354:18: ( SREDNIK instrukcja )*
            loop47:
            do {
                int alt47=2;
                int LA47_0 = input.LA(1);

                if ( (LA47_0==SREDNIK) ) {
                    alt47=1;
                }


                switch (alt47) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:354:20: SREDNIK instrukcja
            	    {
            	    SREDNIK256=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_ciag_instrukcji2490);  
            	    stream_SREDNIK.add(SREDNIK256);

            	    pushFollow(FOLLOW_instrukcja_in_ciag_instrukcji2492);
            	    instrukcja257=instrukcja();

            	    state._fsp--;

            	    stream_instrukcja.add(instrukcja257.getTree());

            	    }
            	    break;

            	default :
            	    break loop47;
                }
            } while (true);



            // AST REWRITE
            // elements: instrukcja
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 354:42: -> ^( BLOCK ( instrukcja )* )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:354:45: ^( BLOCK ( instrukcja )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(BLOCK, "BLOCK"), root_1);

                // /home/ravn/Workspace/pascal4j/src/pascal.g:354:53: ( instrukcja )*
                while ( stream_instrukcja.hasNext() ) {
                    adaptor.addChild(root_1, stream_instrukcja.nextTree());

                }
                stream_instrukcja.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "ciag_instrukcji"

    public static class instrukcja_warunkowa_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_warunkowa"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:357:1: instrukcja_warunkowa : ( instrukcja_jesli | instrukcja_wyboru );
    public final pascalParser.instrukcja_warunkowa_return instrukcja_warunkowa() throws RecognitionException {
        pascalParser.instrukcja_warunkowa_return retval = new pascalParser.instrukcja_warunkowa_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.instrukcja_jesli_return instrukcja_jesli258 = null;

        pascalParser.instrukcja_wyboru_return instrukcja_wyboru259 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:358:5: ( instrukcja_jesli | instrukcja_wyboru )
            int alt48=2;
            int LA48_0 = input.LA(1);

            if ( (LA48_0==IF) ) {
                alt48=1;
            }
            else if ( (LA48_0==CASE) ) {
                alt48=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 48, 0, input);

                throw nvae;
            }
            switch (alt48) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:358:7: instrukcja_jesli
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_jesli_in_instrukcja_warunkowa2521);
                    instrukcja_jesli258=instrukcja_jesli();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_jesli258.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:359:7: instrukcja_wyboru
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_wyboru_in_instrukcja_warunkowa2529);
                    instrukcja_wyboru259=instrukcja_wyboru();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_wyboru259.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_warunkowa"

    public static class instrukcja_jesli_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_jesli"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:362:1: instrukcja_jesli : IF wyrazenie THEN instrukcja ( ELSE instrukcja )? -> ^( IF wyrazenie instrukcja ( instrukcja )? ) ;
    public final pascalParser.instrukcja_jesli_return instrukcja_jesli() throws RecognitionException {
        pascalParser.instrukcja_jesli_return retval = new pascalParser.instrukcja_jesli_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token IF260=null;
        Token THEN262=null;
        Token ELSE264=null;
        pascalParser.wyrazenie_return wyrazenie261 = null;

        pascalParser.instrukcja_return instrukcja263 = null;

        pascalParser.instrukcja_return instrukcja265 = null;


        Object IF260_tree=null;
        Object THEN262_tree=null;
        Object ELSE264_tree=null;
        RewriteRuleTokenStream stream_THEN=new RewriteRuleTokenStream(adaptor,"token THEN");
        RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
        RewriteRuleTokenStream stream_ELSE=new RewriteRuleTokenStream(adaptor,"token ELSE");
        RewriteRuleSubtreeStream stream_wyrazenie=new RewriteRuleSubtreeStream(adaptor,"rule wyrazenie");
        RewriteRuleSubtreeStream stream_instrukcja=new RewriteRuleSubtreeStream(adaptor,"rule instrukcja");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:363:5: ( IF wyrazenie THEN instrukcja ( ELSE instrukcja )? -> ^( IF wyrazenie instrukcja ( instrukcja )? ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:363:7: IF wyrazenie THEN instrukcja ( ELSE instrukcja )?
            {
            IF260=(Token)match(input,IF,FOLLOW_IF_in_instrukcja_jesli2546);  
            stream_IF.add(IF260);

            pushFollow(FOLLOW_wyrazenie_in_instrukcja_jesli2548);
            wyrazenie261=wyrazenie();

            state._fsp--;

            stream_wyrazenie.add(wyrazenie261.getTree());
            THEN262=(Token)match(input,THEN,FOLLOW_THEN_in_instrukcja_jesli2550);  
            stream_THEN.add(THEN262);

            pushFollow(FOLLOW_instrukcja_in_instrukcja_jesli2552);
            instrukcja263=instrukcja();

            state._fsp--;

            stream_instrukcja.add(instrukcja263.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:364:7: ( ELSE instrukcja )?
            int alt49=2;
            int LA49_0 = input.LA(1);

            if ( (LA49_0==ELSE) ) {
                alt49=1;
            }
            switch (alt49) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:365:5: ELSE instrukcja
                    {
                    ELSE264=(Token)match(input,ELSE,FOLLOW_ELSE_in_instrukcja_jesli2566);  
                    stream_ELSE.add(ELSE264);

                    pushFollow(FOLLOW_instrukcja_in_instrukcja_jesli2568);
                    instrukcja265=instrukcja();

                    state._fsp--;

                    stream_instrukcja.add(instrukcja265.getTree());

                    }
                    break;

            }



            // AST REWRITE
            // elements: instrukcja, instrukcja, wyrazenie, IF
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 366:7: -> ^( IF wyrazenie instrukcja ( instrukcja )? )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:366:10: ^( IF wyrazenie instrukcja ( instrukcja )? )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_IF.nextNode(), root_1);

                adaptor.addChild(root_1, stream_wyrazenie.nextTree());
                adaptor.addChild(root_1, stream_instrukcja.nextTree());
                // /home/ravn/Workspace/pascal4j/src/pascal.g:366:36: ( instrukcja )?
                if ( stream_instrukcja.hasNext() ) {
                    adaptor.addChild(root_1, stream_instrukcja.nextTree());

                }
                stream_instrukcja.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_jesli"

    public static class instrukcja_wyboru_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_wyboru"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:369:1: instrukcja_wyboru : CASE wyrazenie OF element_listy_wyboru ( SREDNIK element_listy_wyboru )* ( SREDNIK ELSE ciag_instrukcji )? END -> ^( CASE wyrazenie ( element_listy_wyboru )+ ( ciag_instrukcji )? ) ;
    public final pascalParser.instrukcja_wyboru_return instrukcja_wyboru() throws RecognitionException {
        pascalParser.instrukcja_wyboru_return retval = new pascalParser.instrukcja_wyboru_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token CASE266=null;
        Token OF268=null;
        Token SREDNIK270=null;
        Token SREDNIK272=null;
        Token ELSE273=null;
        Token END275=null;
        pascalParser.wyrazenie_return wyrazenie267 = null;

        pascalParser.element_listy_wyboru_return element_listy_wyboru269 = null;

        pascalParser.element_listy_wyboru_return element_listy_wyboru271 = null;

        pascalParser.ciag_instrukcji_return ciag_instrukcji274 = null;


        Object CASE266_tree=null;
        Object OF268_tree=null;
        Object SREDNIK270_tree=null;
        Object SREDNIK272_tree=null;
        Object ELSE273_tree=null;
        Object END275_tree=null;
        RewriteRuleTokenStream stream_SREDNIK=new RewriteRuleTokenStream(adaptor,"token SREDNIK");
        RewriteRuleTokenStream stream_END=new RewriteRuleTokenStream(adaptor,"token END");
        RewriteRuleTokenStream stream_OF=new RewriteRuleTokenStream(adaptor,"token OF");
        RewriteRuleTokenStream stream_ELSE=new RewriteRuleTokenStream(adaptor,"token ELSE");
        RewriteRuleTokenStream stream_CASE=new RewriteRuleTokenStream(adaptor,"token CASE");
        RewriteRuleSubtreeStream stream_ciag_instrukcji=new RewriteRuleSubtreeStream(adaptor,"rule ciag_instrukcji");
        RewriteRuleSubtreeStream stream_wyrazenie=new RewriteRuleSubtreeStream(adaptor,"rule wyrazenie");
        RewriteRuleSubtreeStream stream_element_listy_wyboru=new RewriteRuleSubtreeStream(adaptor,"rule element_listy_wyboru");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:370:5: ( CASE wyrazenie OF element_listy_wyboru ( SREDNIK element_listy_wyboru )* ( SREDNIK ELSE ciag_instrukcji )? END -> ^( CASE wyrazenie ( element_listy_wyboru )+ ( ciag_instrukcji )? ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:370:7: CASE wyrazenie OF element_listy_wyboru ( SREDNIK element_listy_wyboru )* ( SREDNIK ELSE ciag_instrukcji )? END
            {
            CASE266=(Token)match(input,CASE,FOLLOW_CASE_in_instrukcja_wyboru2604);  
            stream_CASE.add(CASE266);

            pushFollow(FOLLOW_wyrazenie_in_instrukcja_wyboru2606);
            wyrazenie267=wyrazenie();

            state._fsp--;

            stream_wyrazenie.add(wyrazenie267.getTree());
            OF268=(Token)match(input,OF,FOLLOW_OF_in_instrukcja_wyboru2608);  
            stream_OF.add(OF268);

            pushFollow(FOLLOW_element_listy_wyboru_in_instrukcja_wyboru2618);
            element_listy_wyboru269=element_listy_wyboru();

            state._fsp--;

            stream_element_listy_wyboru.add(element_listy_wyboru269.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:371:30: ( SREDNIK element_listy_wyboru )*
            loop50:
            do {
                int alt50=2;
                int LA50_0 = input.LA(1);

                if ( (LA50_0==SREDNIK) ) {
                    int LA50_1 = input.LA(2);

                    if ( (LA50_1==IDENT||(LA50_1>=NUM_INT && LA50_1<=STRING_LITERAL)) ) {
                        alt50=1;
                    }


                }


                switch (alt50) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:371:32: SREDNIK element_listy_wyboru
            	    {
            	    SREDNIK270=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_instrukcja_wyboru2622);  
            	    stream_SREDNIK.add(SREDNIK270);

            	    pushFollow(FOLLOW_element_listy_wyboru_in_instrukcja_wyboru2624);
            	    element_listy_wyboru271=element_listy_wyboru();

            	    state._fsp--;

            	    stream_element_listy_wyboru.add(element_listy_wyboru271.getTree());

            	    }
            	    break;

            	default :
            	    break loop50;
                }
            } while (true);

            // /home/ravn/Workspace/pascal4j/src/pascal.g:372:7: ( SREDNIK ELSE ciag_instrukcji )?
            int alt51=2;
            int LA51_0 = input.LA(1);

            if ( (LA51_0==SREDNIK) ) {
                alt51=1;
            }
            switch (alt51) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:372:9: SREDNIK ELSE ciag_instrukcji
                    {
                    SREDNIK272=(Token)match(input,SREDNIK,FOLLOW_SREDNIK_in_instrukcja_wyboru2637);  
                    stream_SREDNIK.add(SREDNIK272);

                    ELSE273=(Token)match(input,ELSE,FOLLOW_ELSE_in_instrukcja_wyboru2639);  
                    stream_ELSE.add(ELSE273);

                    pushFollow(FOLLOW_ciag_instrukcji_in_instrukcja_wyboru2641);
                    ciag_instrukcji274=ciag_instrukcji();

                    state._fsp--;

                    stream_ciag_instrukcji.add(ciag_instrukcji274.getTree());

                    }
                    break;

            }

            END275=(Token)match(input,END,FOLLOW_END_in_instrukcja_wyboru2652);  
            stream_END.add(END275);



            // AST REWRITE
            // elements: element_listy_wyboru, CASE, wyrazenie, ciag_instrukcji
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 373:11: -> ^( CASE wyrazenie ( element_listy_wyboru )+ ( ciag_instrukcji )? )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:373:14: ^( CASE wyrazenie ( element_listy_wyboru )+ ( ciag_instrukcji )? )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_CASE.nextNode(), root_1);

                adaptor.addChild(root_1, stream_wyrazenie.nextTree());
                if ( !(stream_element_listy_wyboru.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_element_listy_wyboru.hasNext() ) {
                    adaptor.addChild(root_1, stream_element_listy_wyboru.nextTree());

                }
                stream_element_listy_wyboru.reset();
                // /home/ravn/Workspace/pascal4j/src/pascal.g:373:53: ( ciag_instrukcji )?
                if ( stream_ciag_instrukcji.hasNext() ) {
                    adaptor.addChild(root_1, stream_ciag_instrukcji.nextTree());

                }
                stream_ciag_instrukcji.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_wyboru"

    public static class element_listy_wyboru_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "element_listy_wyboru"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:376:1: element_listy_wyboru : lista_stalych_wyboru DWUKROPEK instrukcja -> ^( DWUKROPEK lista_stalych_wyboru instrukcja ) ;
    public final pascalParser.element_listy_wyboru_return element_listy_wyboru() throws RecognitionException {
        pascalParser.element_listy_wyboru_return retval = new pascalParser.element_listy_wyboru_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token DWUKROPEK277=null;
        pascalParser.lista_stalych_wyboru_return lista_stalych_wyboru276 = null;

        pascalParser.instrukcja_return instrukcja278 = null;


        Object DWUKROPEK277_tree=null;
        RewriteRuleTokenStream stream_DWUKROPEK=new RewriteRuleTokenStream(adaptor,"token DWUKROPEK");
        RewriteRuleSubtreeStream stream_lista_stalych_wyboru=new RewriteRuleSubtreeStream(adaptor,"rule lista_stalych_wyboru");
        RewriteRuleSubtreeStream stream_instrukcja=new RewriteRuleSubtreeStream(adaptor,"rule instrukcja");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:377:5: ( lista_stalych_wyboru DWUKROPEK instrukcja -> ^( DWUKROPEK lista_stalych_wyboru instrukcja ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:377:7: lista_stalych_wyboru DWUKROPEK instrukcja
            {
            pushFollow(FOLLOW_lista_stalych_wyboru_in_element_listy_wyboru2683);
            lista_stalych_wyboru276=lista_stalych_wyboru();

            state._fsp--;

            stream_lista_stalych_wyboru.add(lista_stalych_wyboru276.getTree());
            DWUKROPEK277=(Token)match(input,DWUKROPEK,FOLLOW_DWUKROPEK_in_element_listy_wyboru2685);  
            stream_DWUKROPEK.add(DWUKROPEK277);

            pushFollow(FOLLOW_instrukcja_in_element_listy_wyboru2687);
            instrukcja278=instrukcja();

            state._fsp--;

            stream_instrukcja.add(instrukcja278.getTree());


            // AST REWRITE
            // elements: DWUKROPEK, lista_stalych_wyboru, instrukcja
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 377:49: -> ^( DWUKROPEK lista_stalych_wyboru instrukcja )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:377:52: ^( DWUKROPEK lista_stalych_wyboru instrukcja )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_DWUKROPEK.nextNode(), root_1);

                adaptor.addChild(root_1, stream_lista_stalych_wyboru.nextTree());
                adaptor.addChild(root_1, stream_instrukcja.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "element_listy_wyboru"

    public static class instrukcja_iteracyjna_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_iteracyjna"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:380:1: instrukcja_iteracyjna : ( instrukcja_dopoki | instrukcja_powtarzaj | instrukcja_dla );
    public final pascalParser.instrukcja_iteracyjna_return instrukcja_iteracyjna() throws RecognitionException {
        pascalParser.instrukcja_iteracyjna_return retval = new pascalParser.instrukcja_iteracyjna_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.instrukcja_dopoki_return instrukcja_dopoki279 = null;

        pascalParser.instrukcja_powtarzaj_return instrukcja_powtarzaj280 = null;

        pascalParser.instrukcja_dla_return instrukcja_dla281 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:381:5: ( instrukcja_dopoki | instrukcja_powtarzaj | instrukcja_dla )
            int alt52=3;
            switch ( input.LA(1) ) {
            case WHILE:
                {
                alt52=1;
                }
                break;
            case REPEAT:
                {
                alt52=2;
                }
                break;
            case FOR:
                {
                alt52=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 52, 0, input);

                throw nvae;
            }

            switch (alt52) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:381:7: instrukcja_dopoki
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_dopoki_in_instrukcja_iteracyjna2714);
                    instrukcja_dopoki279=instrukcja_dopoki();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_dopoki279.getTree());

                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:382:7: instrukcja_powtarzaj
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_powtarzaj_in_instrukcja_iteracyjna2722);
                    instrukcja_powtarzaj280=instrukcja_powtarzaj();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_powtarzaj280.getTree());

                    }
                    break;
                case 3 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:383:7: instrukcja_dla
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_instrukcja_dla_in_instrukcja_iteracyjna2730);
                    instrukcja_dla281=instrukcja_dla();

                    state._fsp--;

                    adaptor.addChild(root_0, instrukcja_dla281.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_iteracyjna"

    public static class instrukcja_dopoki_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_dopoki"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:386:1: instrukcja_dopoki : WHILE wyrazenie DO instrukcja -> ^( WHILE wyrazenie instrukcja ) ;
    public final pascalParser.instrukcja_dopoki_return instrukcja_dopoki() throws RecognitionException {
        pascalParser.instrukcja_dopoki_return retval = new pascalParser.instrukcja_dopoki_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token WHILE282=null;
        Token DO284=null;
        pascalParser.wyrazenie_return wyrazenie283 = null;

        pascalParser.instrukcja_return instrukcja285 = null;


        Object WHILE282_tree=null;
        Object DO284_tree=null;
        RewriteRuleTokenStream stream_DO=new RewriteRuleTokenStream(adaptor,"token DO");
        RewriteRuleTokenStream stream_WHILE=new RewriteRuleTokenStream(adaptor,"token WHILE");
        RewriteRuleSubtreeStream stream_wyrazenie=new RewriteRuleSubtreeStream(adaptor,"rule wyrazenie");
        RewriteRuleSubtreeStream stream_instrukcja=new RewriteRuleSubtreeStream(adaptor,"rule instrukcja");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:387:5: ( WHILE wyrazenie DO instrukcja -> ^( WHILE wyrazenie instrukcja ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:387:7: WHILE wyrazenie DO instrukcja
            {
            WHILE282=(Token)match(input,WHILE,FOLLOW_WHILE_in_instrukcja_dopoki2747);  
            stream_WHILE.add(WHILE282);

            pushFollow(FOLLOW_wyrazenie_in_instrukcja_dopoki2749);
            wyrazenie283=wyrazenie();

            state._fsp--;

            stream_wyrazenie.add(wyrazenie283.getTree());
            DO284=(Token)match(input,DO,FOLLOW_DO_in_instrukcja_dopoki2751);  
            stream_DO.add(DO284);

            pushFollow(FOLLOW_instrukcja_in_instrukcja_dopoki2753);
            instrukcja285=instrukcja();

            state._fsp--;

            stream_instrukcja.add(instrukcja285.getTree());


            // AST REWRITE
            // elements: instrukcja, wyrazenie, WHILE
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 387:37: -> ^( WHILE wyrazenie instrukcja )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:387:40: ^( WHILE wyrazenie instrukcja )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_WHILE.nextNode(), root_1);

                adaptor.addChild(root_1, stream_wyrazenie.nextTree());
                adaptor.addChild(root_1, stream_instrukcja.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_dopoki"

    public static class instrukcja_powtarzaj_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_powtarzaj"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:390:1: instrukcja_powtarzaj : REPEAT ciag_instrukcji UNTIL wyrazenie -> ^( REPEAT ciag_instrukcji wyrazenie ) ;
    public final pascalParser.instrukcja_powtarzaj_return instrukcja_powtarzaj() throws RecognitionException {
        pascalParser.instrukcja_powtarzaj_return retval = new pascalParser.instrukcja_powtarzaj_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token REPEAT286=null;
        Token UNTIL288=null;
        pascalParser.ciag_instrukcji_return ciag_instrukcji287 = null;

        pascalParser.wyrazenie_return wyrazenie289 = null;


        Object REPEAT286_tree=null;
        Object UNTIL288_tree=null;
        RewriteRuleTokenStream stream_REPEAT=new RewriteRuleTokenStream(adaptor,"token REPEAT");
        RewriteRuleTokenStream stream_UNTIL=new RewriteRuleTokenStream(adaptor,"token UNTIL");
        RewriteRuleSubtreeStream stream_ciag_instrukcji=new RewriteRuleSubtreeStream(adaptor,"rule ciag_instrukcji");
        RewriteRuleSubtreeStream stream_wyrazenie=new RewriteRuleSubtreeStream(adaptor,"rule wyrazenie");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:391:5: ( REPEAT ciag_instrukcji UNTIL wyrazenie -> ^( REPEAT ciag_instrukcji wyrazenie ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:391:7: REPEAT ciag_instrukcji UNTIL wyrazenie
            {
            REPEAT286=(Token)match(input,REPEAT,FOLLOW_REPEAT_in_instrukcja_powtarzaj2780);  
            stream_REPEAT.add(REPEAT286);

            pushFollow(FOLLOW_ciag_instrukcji_in_instrukcja_powtarzaj2782);
            ciag_instrukcji287=ciag_instrukcji();

            state._fsp--;

            stream_ciag_instrukcji.add(ciag_instrukcji287.getTree());
            UNTIL288=(Token)match(input,UNTIL,FOLLOW_UNTIL_in_instrukcja_powtarzaj2784);  
            stream_UNTIL.add(UNTIL288);

            pushFollow(FOLLOW_wyrazenie_in_instrukcja_powtarzaj2786);
            wyrazenie289=wyrazenie();

            state._fsp--;

            stream_wyrazenie.add(wyrazenie289.getTree());


            // AST REWRITE
            // elements: REPEAT, ciag_instrukcji, wyrazenie
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 391:46: -> ^( REPEAT ciag_instrukcji wyrazenie )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:391:49: ^( REPEAT ciag_instrukcji wyrazenie )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_REPEAT.nextNode(), root_1);

                adaptor.addChild(root_1, stream_ciag_instrukcji.nextTree());
                adaptor.addChild(root_1, stream_wyrazenie.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_powtarzaj"

    public static class instrukcja_dla_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_dla"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:394:1: instrukcja_dla : FOR identyfikator PRZYPISANIE sekwencja_for DO instrukcja -> ^( FOR identyfikator sekwencja_for instrukcja ) ;
    public final pascalParser.instrukcja_dla_return instrukcja_dla() throws RecognitionException {
        pascalParser.instrukcja_dla_return retval = new pascalParser.instrukcja_dla_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token FOR290=null;
        Token PRZYPISANIE292=null;
        Token DO294=null;
        pascalParser.identyfikator_return identyfikator291 = null;

        pascalParser.sekwencja_for_return sekwencja_for293 = null;

        pascalParser.instrukcja_return instrukcja295 = null;


        Object FOR290_tree=null;
        Object PRZYPISANIE292_tree=null;
        Object DO294_tree=null;
        RewriteRuleTokenStream stream_FOR=new RewriteRuleTokenStream(adaptor,"token FOR");
        RewriteRuleTokenStream stream_DO=new RewriteRuleTokenStream(adaptor,"token DO");
        RewriteRuleTokenStream stream_PRZYPISANIE=new RewriteRuleTokenStream(adaptor,"token PRZYPISANIE");
        RewriteRuleSubtreeStream stream_identyfikator=new RewriteRuleSubtreeStream(adaptor,"rule identyfikator");
        RewriteRuleSubtreeStream stream_sekwencja_for=new RewriteRuleSubtreeStream(adaptor,"rule sekwencja_for");
        RewriteRuleSubtreeStream stream_instrukcja=new RewriteRuleSubtreeStream(adaptor,"rule instrukcja");
        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:395:5: ( FOR identyfikator PRZYPISANIE sekwencja_for DO instrukcja -> ^( FOR identyfikator sekwencja_for instrukcja ) )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:395:7: FOR identyfikator PRZYPISANIE sekwencja_for DO instrukcja
            {
            FOR290=(Token)match(input,FOR,FOLLOW_FOR_in_instrukcja_dla2813);  
            stream_FOR.add(FOR290);

            pushFollow(FOLLOW_identyfikator_in_instrukcja_dla2815);
            identyfikator291=identyfikator();

            state._fsp--;

            stream_identyfikator.add(identyfikator291.getTree());
            PRZYPISANIE292=(Token)match(input,PRZYPISANIE,FOLLOW_PRZYPISANIE_in_instrukcja_dla2817);  
            stream_PRZYPISANIE.add(PRZYPISANIE292);

            pushFollow(FOLLOW_sekwencja_for_in_instrukcja_dla2819);
            sekwencja_for293=sekwencja_for();

            state._fsp--;

            stream_sekwencja_for.add(sekwencja_for293.getTree());
            DO294=(Token)match(input,DO,FOLLOW_DO_in_instrukcja_dla2821);  
            stream_DO.add(DO294);

            pushFollow(FOLLOW_instrukcja_in_instrukcja_dla2823);
            instrukcja295=instrukcja();

            state._fsp--;

            stream_instrukcja.add(instrukcja295.getTree());


            // AST REWRITE
            // elements: sekwencja_for, instrukcja, identyfikator, FOR
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 395:65: -> ^( FOR identyfikator sekwencja_for instrukcja )
            {
                // /home/ravn/Workspace/pascal4j/src/pascal.g:395:68: ^( FOR identyfikator sekwencja_for instrukcja )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(stream_FOR.nextNode(), root_1);

                adaptor.addChild(root_1, stream_identyfikator.nextTree());
                adaptor.addChild(root_1, stream_sekwencja_for.nextTree());
                adaptor.addChild(root_1, stream_instrukcja.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_dla"

    public static class sekwencja_for_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "sekwencja_for"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:398:1: sekwencja_for : wartosc_poczatkowa ( TO | DOWNTO ) wartosc_koncowa ;
    public final pascalParser.sekwencja_for_return sekwencja_for() throws RecognitionException {
        pascalParser.sekwencja_for_return retval = new pascalParser.sekwencja_for_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token TO297=null;
        Token DOWNTO298=null;
        pascalParser.wartosc_poczatkowa_return wartosc_poczatkowa296 = null;

        pascalParser.wartosc_koncowa_return wartosc_koncowa299 = null;


        Object TO297_tree=null;
        Object DOWNTO298_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:399:5: ( wartosc_poczatkowa ( TO | DOWNTO ) wartosc_koncowa )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:399:7: wartosc_poczatkowa ( TO | DOWNTO ) wartosc_koncowa
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_wartosc_poczatkowa_in_sekwencja_for2852);
            wartosc_poczatkowa296=wartosc_poczatkowa();

            state._fsp--;

            adaptor.addChild(root_0, wartosc_poczatkowa296.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:399:26: ( TO | DOWNTO )
            int alt53=2;
            int LA53_0 = input.LA(1);

            if ( (LA53_0==TO) ) {
                alt53=1;
            }
            else if ( (LA53_0==DOWNTO) ) {
                alt53=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 53, 0, input);

                throw nvae;
            }
            switch (alt53) {
                case 1 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:399:27: TO
                    {
                    TO297=(Token)match(input,TO,FOLLOW_TO_in_sekwencja_for2855); 
                    TO297_tree = (Object)adaptor.create(TO297);
                    root_0 = (Object)adaptor.becomeRoot(TO297_tree, root_0);


                    }
                    break;
                case 2 :
                    // /home/ravn/Workspace/pascal4j/src/pascal.g:399:33: DOWNTO
                    {
                    DOWNTO298=(Token)match(input,DOWNTO,FOLLOW_DOWNTO_in_sekwencja_for2860); 
                    DOWNTO298_tree = (Object)adaptor.create(DOWNTO298);
                    root_0 = (Object)adaptor.becomeRoot(DOWNTO298_tree, root_0);


                    }
                    break;

            }

            pushFollow(FOLLOW_wartosc_koncowa_in_sekwencja_for2864);
            wartosc_koncowa299=wartosc_koncowa();

            state._fsp--;

            adaptor.addChild(root_0, wartosc_koncowa299.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "sekwencja_for"

    public static class wartosc_poczatkowa_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "wartosc_poczatkowa"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:402:1: wartosc_poczatkowa : wyrazenie ;
    public final pascalParser.wartosc_poczatkowa_return wartosc_poczatkowa() throws RecognitionException {
        pascalParser.wartosc_poczatkowa_return retval = new pascalParser.wartosc_poczatkowa_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.wyrazenie_return wyrazenie300 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:403:5: ( wyrazenie )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:403:7: wyrazenie
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_wyrazenie_in_wartosc_poczatkowa2881);
            wyrazenie300=wyrazenie();

            state._fsp--;

            adaptor.addChild(root_0, wyrazenie300.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "wartosc_poczatkowa"

    public static class wartosc_koncowa_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "wartosc_koncowa"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:406:1: wartosc_koncowa : wyrazenie ;
    public final pascalParser.wartosc_koncowa_return wartosc_koncowa() throws RecognitionException {
        pascalParser.wartosc_koncowa_return retval = new pascalParser.wartosc_koncowa_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        pascalParser.wyrazenie_return wyrazenie301 = null;



        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:407:5: ( wyrazenie )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:407:7: wyrazenie
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_wyrazenie_in_wartosc_koncowa2898);
            wyrazenie301=wyrazenie();

            state._fsp--;

            adaptor.addChild(root_0, wyrazenie301.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "wartosc_koncowa"

    public static class instrukcja_wiazaca_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "instrukcja_wiazaca"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:410:1: instrukcja_wiazaca : WITH lista_zmiennych_rekordowych DO instrukcja ;
    public final pascalParser.instrukcja_wiazaca_return instrukcja_wiazaca() throws RecognitionException {
        pascalParser.instrukcja_wiazaca_return retval = new pascalParser.instrukcja_wiazaca_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token WITH302=null;
        Token DO304=null;
        pascalParser.lista_zmiennych_rekordowych_return lista_zmiennych_rekordowych303 = null;

        pascalParser.instrukcja_return instrukcja305 = null;


        Object WITH302_tree=null;
        Object DO304_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:411:5: ( WITH lista_zmiennych_rekordowych DO instrukcja )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:411:7: WITH lista_zmiennych_rekordowych DO instrukcja
            {
            root_0 = (Object)adaptor.nil();

            WITH302=(Token)match(input,WITH,FOLLOW_WITH_in_instrukcja_wiazaca2915); 
            WITH302_tree = (Object)adaptor.create(WITH302);
            root_0 = (Object)adaptor.becomeRoot(WITH302_tree, root_0);

            pushFollow(FOLLOW_lista_zmiennych_rekordowych_in_instrukcja_wiazaca2918);
            lista_zmiennych_rekordowych303=lista_zmiennych_rekordowych();

            state._fsp--;

            adaptor.addChild(root_0, lista_zmiennych_rekordowych303.getTree());
            DO304=(Token)match(input,DO,FOLLOW_DO_in_instrukcja_wiazaca2920); 
            pushFollow(FOLLOW_instrukcja_in_instrukcja_wiazaca2923);
            instrukcja305=instrukcja();

            state._fsp--;

            adaptor.addChild(root_0, instrukcja305.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "instrukcja_wiazaca"

    public static class lista_zmiennych_rekordowych_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "lista_zmiennych_rekordowych"
    // /home/ravn/Workspace/pascal4j/src/pascal.g:414:1: lista_zmiennych_rekordowych : zmienna ( PRZECINEK zmienna )* ;
    public final pascalParser.lista_zmiennych_rekordowych_return lista_zmiennych_rekordowych() throws RecognitionException {
        pascalParser.lista_zmiennych_rekordowych_return retval = new pascalParser.lista_zmiennych_rekordowych_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token PRZECINEK307=null;
        pascalParser.zmienna_return zmienna306 = null;

        pascalParser.zmienna_return zmienna308 = null;


        Object PRZECINEK307_tree=null;

        try {
            // /home/ravn/Workspace/pascal4j/src/pascal.g:415:5: ( zmienna ( PRZECINEK zmienna )* )
            // /home/ravn/Workspace/pascal4j/src/pascal.g:415:7: zmienna ( PRZECINEK zmienna )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_zmienna_in_lista_zmiennych_rekordowych2940);
            zmienna306=zmienna();

            state._fsp--;

            adaptor.addChild(root_0, zmienna306.getTree());
            // /home/ravn/Workspace/pascal4j/src/pascal.g:415:15: ( PRZECINEK zmienna )*
            loop54:
            do {
                int alt54=2;
                int LA54_0 = input.LA(1);

                if ( (LA54_0==PRZECINEK) ) {
                    alt54=1;
                }


                switch (alt54) {
            	case 1 :
            	    // /home/ravn/Workspace/pascal4j/src/pascal.g:415:17: PRZECINEK zmienna
            	    {
            	    PRZECINEK307=(Token)match(input,PRZECINEK,FOLLOW_PRZECINEK_in_lista_zmiennych_rekordowych2944); 
            	    pushFollow(FOLLOW_zmienna_in_lista_zmiennych_rekordowych2947);
            	    zmienna308=zmienna();

            	    state._fsp--;

            	    adaptor.addChild(root_0, zmienna308.getTree());

            	    }
            	    break;

            	default :
            	    break loop54;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "lista_zmiennych_rekordowych"

    // Delegated rules


 

    public static final BitSet FOLLOW_naglowek_programu_in_program104 = new BitSet(new long[]{0x0380002050000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_blok_in_program112 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_KROPKA_in_program120 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PROGRAM_in_naglowek_programu138 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_identyfikator_in_naglowek_programu140 = new BitSet(new long[]{0x0000000005000000L});
    public static final BitSet FOLLOW_LNAWIAS_in_naglowek_programu143 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_lista_identyfikatorow_in_naglowek_programu145 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_PNAWIAS_in_naglowek_programu147 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_naglowek_programu151 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_identyfikator179 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_czesc_deklarujaca_etykiety_in_blok198 = new BitSet(new long[]{0x0380002050000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_czesc_definiujaca_stale_in_blok208 = new BitSet(new long[]{0x0380002050000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_czesc_definiujaca_typy_in_blok218 = new BitSet(new long[]{0x0380002050000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_czesc_deklarujaca_zmienne_in_blok228 = new BitSet(new long[]{0x0380002050000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_czesc_deklarujaca_procedury_i_funkcje_in_blok238 = new BitSet(new long[]{0x0380002050000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_instrukcja_zlozona_in_blok255 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LABEL_in_czesc_deklarujaca_etykiety272 = new BitSet(new long[]{0x0000000100000000L});
    public static final BitSet FOLLOW_etykieta_in_czesc_deklarujaca_etykiety274 = new BitSet(new long[]{0x0000000024000000L});
    public static final BitSet FOLLOW_PRZECINEK_in_czesc_deklarujaca_etykiety278 = new BitSet(new long[]{0x0000000100000000L});
    public static final BitSet FOLLOW_etykieta_in_czesc_deklarujaca_etykiety280 = new BitSet(new long[]{0x0000000024000000L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_deklarujaca_etykiety285 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_liczba_calkowita_bez_znaku_in_etykieta311 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CONST_in_czesc_definiujaca_stale328 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_definicja_stalej_in_czesc_definiujaca_stale330 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_definiujaca_stale334 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_definicja_stalej_in_czesc_definiujaca_stale336 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_definiujaca_stale341 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identyfikator_in_definicja_stalej367 = new BitSet(new long[]{0x0000000080000000L});
    public static final BitSet FOLLOW_ROWNOSC_in_definicja_stalej369 = new BitSet(new long[]{0x0000001F08000000L});
    public static final BitSet FOLLOW_stala_in_definicja_stalej371 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_liczba_bez_znaku_in_stala398 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_znak_in_stala406 = new BitSet(new long[]{0x0000000300000000L});
    public static final BitSet FOLLOW_liczba_bez_znaku_in_stala408 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identyfikator_in_stala424 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_znak_in_stala432 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_identyfikator_in_stala434 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_napis_in_stala450 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_liczba_calkowita_bez_znaku_in_liczba_bez_znaku467 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_liczba_rzeczywista_bez_znaku_in_liczba_bez_znaku475 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NUM_INT_in_liczba_calkowita_bez_znaku492 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NUM_REAL_in_liczba_rzeczywista_bez_znaku509 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_znak0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STRING_LITERAL_in_napis547 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TYPE_in_czesc_definiujaca_typy564 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_definicja_typu_in_czesc_definiujaca_typy566 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_definiujaca_typy570 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_definicja_typu_in_czesc_definiujaca_typy572 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_definiujaca_typy577 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identyfikator_in_definicja_typu603 = new BitSet(new long[]{0x0000000080000000L});
    public static final BitSet FOLLOW_ROWNOSC_in_definicja_typu605 = new BitSet(new long[]{0x00441FDF09000000L});
    public static final BitSet FOLLOW_nowy_typ_in_definicja_typu609 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nowy_typ_prosty_in_nowy_typ638 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nowy_typ_strukturalny_in_nowy_typ646 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nowy_typ_wskaznikowy_in_nowy_typ654 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typ_wyliczeniowy_in_nowy_typ_prosty671 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typ_okrojony_in_nowy_typ_prosty679 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identyfikator_typu_in_nowy_typ_prosty687 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_stringtype_in_nowy_typ_prosty695 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LNAWIAS_in_typ_wyliczeniowy712 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_lista_identyfikatorow_in_typ_wyliczeniowy714 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_PNAWIAS_in_typ_wyliczeniowy716 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_stala_in_typ_okrojony741 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_DWIEKROPKI_in_typ_okrojony743 = new BitSet(new long[]{0x0000001F08000000L});
    public static final BitSet FOLLOW_stala_in_typ_okrojony745 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identyfikator_in_identyfikator_typu772 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CHAR_in_identyfikator_typu780 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BOOLEAN_in_identyfikator_typu788 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INTEGER_in_identyfikator_typu796 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_REAL_in_identyfikator_typu804 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STRING_in_identyfikator_typu812 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PACKED_in_nowy_typ_strukturalny829 = new BitSet(new long[]{0x0004180000000000L});
    public static final BitSet FOLLOW_typ_strukturalny_niespakowany_in_nowy_typ_strukturalny831 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typ_strukturalny_niespakowany_in_nowy_typ_strukturalny847 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typ_tablicowy_in_typ_strukturalny_niespakowany864 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typ_rekordowy_in_typ_strukturalny_niespakowany872 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STRING_in_stringtype889 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_LNAWIAS_in_stringtype892 = new BitSet(new long[]{0x0000000308000000L});
    public static final BitSet FOLLOW_identyfikator_in_stringtype896 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_liczba_bez_znaku_in_stringtype898 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_PNAWIAS_in_stringtype901 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ARRAY_in_typ_tablicowy919 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_LNAWIASKWADRATOWY_in_typ_tablicowy921 = new BitSet(new long[]{0x000007DF09000000L});
    public static final BitSet FOLLOW_lista_typow_indeksowych_in_typ_tablicowy923 = new BitSet(new long[]{0x0000400000000000L});
    public static final BitSet FOLLOW_PNAWIASKWADRATOWY_in_typ_tablicowy925 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_OF_in_typ_tablicowy927 = new BitSet(new long[]{0x00441FDF09000000L});
    public static final BitSet FOLLOW_typ_skladowy_in_typ_tablicowy929 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ARRAY_in_typ_tablicowy947 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_LNAWIAS2_in_typ_tablicowy949 = new BitSet(new long[]{0x000007DF09000000L});
    public static final BitSet FOLLOW_lista_typow_indeksowych_in_typ_tablicowy951 = new BitSet(new long[]{0x0002000000000000L});
    public static final BitSet FOLLOW_PNAWIAS2_in_typ_tablicowy953 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_OF_in_typ_tablicowy955 = new BitSet(new long[]{0x00441FDF09000000L});
    public static final BitSet FOLLOW_typ_skladowy_in_typ_tablicowy957 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typ_indeksowy_in_lista_typow_indeksowych978 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_PRZECINEK_in_lista_typow_indeksowych982 = new BitSet(new long[]{0x000007DF09000000L});
    public static final BitSet FOLLOW_typ_indeksowy_in_lista_typow_indeksowych984 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_nowy_typ_prosty_in_typ_indeksowy1010 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nowy_typ_in_typ_skladowy1027 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RECORD_in_typ_rekordowy1044 = new BitSet(new long[]{0x0020000008000000L});
    public static final BitSet FOLLOW_lista_pol_in_typ_rekordowy1046 = new BitSet(new long[]{0x0008000000000000L});
    public static final BitSet FOLLOW_END_in_typ_rekordowy1048 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_czesc_stala_in_lista_pol1075 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_SREDNIK_in_lista_pol1079 = new BitSet(new long[]{0x0020000008000000L});
    public static final BitSet FOLLOW_czesc_zmienna_in_lista_pol1081 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SREDNIK_in_lista_pol1085 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_czesc_zmienna_in_lista_pol1109 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_sekcja_rekordu_in_czesc_stala1142 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_stala1146 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_sekcja_rekordu_in_czesc_stala1149 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_lista_identyfikatorow_in_sekcja_rekordu1169 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_DWUKROPEK_in_sekcja_rekordu1171 = new BitSet(new long[]{0x00441FDF09000000L});
    public static final BitSet FOLLOW_nowy_typ_in_sekcja_rekordu1173 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CASE_in_czesc_zmienna1200 = new BitSet(new long[]{0x000007C008000000L});
    public static final BitSet FOLLOW_selektor_wariantu_in_czesc_zmienna1202 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_OF_in_czesc_zmienna1204 = new BitSet(new long[]{0x0000001F08000000L});
    public static final BitSet FOLLOW_wariant_in_czesc_zmienna1206 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_zmienna1210 = new BitSet(new long[]{0x0000001F08000000L});
    public static final BitSet FOLLOW_wariant_in_czesc_zmienna1212 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_zmienna1216 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_identyfikator_in_selektor_wariantu1248 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_DWUKROPEK_in_selektor_wariantu1250 = new BitSet(new long[]{0x000007C008000000L});
    public static final BitSet FOLLOW_identyfikator_typu_in_selektor_wariantu1252 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identyfikator_typu_in_selektor_wariantu1271 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_lista_stalych_wyboru_in_wariant1296 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_DWUKROPEK_in_wariant1298 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_LNAWIAS_in_wariant1300 = new BitSet(new long[]{0x0020000008000000L});
    public static final BitSet FOLLOW_lista_pol_in_wariant1302 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_PNAWIAS_in_wariant1304 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WSKAZNIK_in_nowy_typ_wskaznikowy1331 = new BitSet(new long[]{0x000007C008000000L});
    public static final BitSet FOLLOW_identyfikator_typu_in_nowy_typ_wskaznikowy1333 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VAR_in_czesc_deklarujaca_zmienne1358 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_deklaracja_zmiennej_in_czesc_deklarujaca_zmienne1360 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_deklarujaca_zmienne1364 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_deklaracja_zmiennej_in_czesc_deklarujaca_zmienne1366 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_deklarujaca_zmienne1371 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_lista_identyfikatorow_in_deklaracja_zmiennej1397 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_DWUKROPEK_in_deklaracja_zmiennej1399 = new BitSet(new long[]{0x00441FDF09000000L});
    public static final BitSet FOLLOW_nowy_typ_in_deklaracja_zmiennej1401 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_deklaracja_procedury_lub_funkcji_in_czesc_deklarujaca_procedury_i_funkcje1428 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_czesc_deklarujaca_procedury_i_funkcje1430 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_deklaracja_procedury_in_deklaracja_procedury_lub_funkcji1448 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_deklaracja_funkcji_in_deklaracja_procedury_lub_funkcji1456 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PROCEDURE_in_deklaracja_procedury1473 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_identyfikator_in_deklaracja_procedury1475 = new BitSet(new long[]{0x0000000005000000L});
    public static final BitSet FOLLOW_lista_parametrow_formalnych_in_deklaracja_procedury1478 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_deklaracja_procedury1482 = new BitSet(new long[]{0x0380002050000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_blok_in_deklaracja_procedury1484 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LNAWIAS_in_lista_parametrow_formalnych1514 = new BitSet(new long[]{0x0080000008000000L});
    public static final BitSet FOLLOW_sekcja_parametrow_formalnych_in_lista_parametrow_formalnych1516 = new BitSet(new long[]{0x0000000006000000L});
    public static final BitSet FOLLOW_SREDNIK_in_lista_parametrow_formalnych1520 = new BitSet(new long[]{0x0080000008000000L});
    public static final BitSet FOLLOW_sekcja_parametrow_formalnych_in_lista_parametrow_formalnych1522 = new BitSet(new long[]{0x0000000006000000L});
    public static final BitSet FOLLOW_PNAWIAS_in_lista_parametrow_formalnych1527 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_grupa_parametrow_in_sekcja_parametrow_formalnych1553 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VAR_in_sekcja_parametrow_formalnych1561 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_grupa_parametrow_in_sekcja_parametrow_formalnych1564 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_lista_identyfikatorow_in_grupa_parametrow1582 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_DWUKROPEK_in_grupa_parametrow1584 = new BitSet(new long[]{0x000007C008000000L});
    public static final BitSet FOLLOW_identyfikator_typu_in_grupa_parametrow1586 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identyfikator_in_lista_identyfikatorow1613 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_PRZECINEK_in_lista_identyfikatorow1617 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_identyfikator_in_lista_identyfikatorow1619 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_stala_in_lista_stalych_wyboru1648 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_PRZECINEK_in_lista_stalych_wyboru1652 = new BitSet(new long[]{0x0000001F08000000L});
    public static final BitSet FOLLOW_stala_in_lista_stalych_wyboru1654 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_FUNCTION_in_deklaracja_funkcji1683 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_identyfikator_in_deklaracja_funkcji1685 = new BitSet(new long[]{0x0010000001000000L});
    public static final BitSet FOLLOW_lista_parametrow_formalnych_in_deklaracja_funkcji1688 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_DWUKROPEK_in_deklaracja_funkcji1692 = new BitSet(new long[]{0x000007C008000000L});
    public static final BitSet FOLLOW_typ_wyniku_in_deklaracja_funkcji1694 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_deklaracja_funkcji1696 = new BitSet(new long[]{0x0380002050000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_blok_in_deklaracja_funkcji1699 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identyfikator_typu_in_typ_wyniku1731 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_etykieta_in_instrukcja1748 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_DWUKROPEK_in_instrukcja1750 = new BitSet(new long[]{0x03A0002058000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_instrukcja_bez_etykiety_in_instrukcja1752 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_bez_etykiety_in_instrukcja1770 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_prosta_in_instrukcja_bez_etykiety1787 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_strukturalna_in_instrukcja_bez_etykiety1795 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_przypisania_in_instrukcja_prosta1812 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_procedury_in_instrukcja_prosta1820 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_skoku_in_instrukcja_prosta1828 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_pusta_in_instrukcja_prosta1836 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_zmienna_in_instrukcja_przypisania1853 = new BitSet(new long[]{0x0400000000000000L});
    public static final BitSet FOLLOW_PRZYPISANIE_in_instrukcja_przypisania1855 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wyrazenie_in_instrukcja_przypisania1857 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identyfikator_in_zmienna1887 = new BitSet(new long[]{0x0041200000400002L});
    public static final BitSet FOLLOW_LNAWIASKWADRATOWY_in_zmienna1897 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wyrazenie_in_zmienna1900 = new BitSet(new long[]{0x0000400020000000L});
    public static final BitSet FOLLOW_PRZECINEK_in_zmienna1904 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wyrazenie_in_zmienna1907 = new BitSet(new long[]{0x0000400020000000L});
    public static final BitSet FOLLOW_PNAWIASKWADRATOWY_in_zmienna1911 = new BitSet(new long[]{0x0041200000400002L});
    public static final BitSet FOLLOW_LNAWIAS2_in_zmienna1922 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wyrazenie_in_zmienna1925 = new BitSet(new long[]{0x0002000020000000L});
    public static final BitSet FOLLOW_PRZECINEK_in_zmienna1929 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wyrazenie_in_zmienna1932 = new BitSet(new long[]{0x0002000020000000L});
    public static final BitSet FOLLOW_PNAWIAS2_in_zmienna1936 = new BitSet(new long[]{0x0041200000400002L});
    public static final BitSet FOLLOW_KROPKA_in_zmienna1947 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_identyfikator_in_zmienna1950 = new BitSet(new long[]{0x0041200000400002L});
    public static final BitSet FOLLOW_WSKAZNIK_in_zmienna1960 = new BitSet(new long[]{0x0041200000400002L});
    public static final BitSet FOLLOW_proste_wyrazenie_in_wyrazenie1987 = new BitSet(new long[]{0xF800000080000002L,0x0000000000000001L});
    public static final BitSet FOLLOW_ROWNOSC_in_wyrazenie1995 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_NIEROWNOSC_in_wyrazenie2000 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_MNIEJSZY_in_wyrazenie2005 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_MNIEJSZYLUBROWNY_in_wyrazenie2010 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_WIEKSZYLUBROWNY_in_wyrazenie2015 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_WIEKSZY_in_wyrazenie2020 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_IN_in_wyrazenie2025 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_proste_wyrazenie_in_wyrazenie2029 = new BitSet(new long[]{0xF800000080000002L,0x0000000000000001L});
    public static final BitSet FOLLOW_skladnik_in_proste_wyrazenie2049 = new BitSet(new long[]{0x0000000C00000002L,0x0000000000000002L});
    public static final BitSet FOLLOW_PLUS_in_proste_wyrazenie2054 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_MINUS_in_proste_wyrazenie2059 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_OR_in_proste_wyrazenie2064 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_skladnik_in_proste_wyrazenie2068 = new BitSet(new long[]{0x0000000C00000002L,0x0000000000000002L});
    public static final BitSet FOLLOW_czynnik_in_skladnik2085 = new BitSet(new long[]{0x0000000000000002L,0x000000000000007CL});
    public static final BitSet FOLLOW_GWIAZDKA_in_skladnik2090 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_SLASH_in_skladnik2095 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_DIV_in_skladnik2100 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_MOD_in_skladnik2105 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_AND_in_skladnik2110 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_czynnik_in_skladnik2114 = new BitSet(new long[]{0x0000000000000002L,0x000000000000007CL});
    public static final BitSet FOLLOW_PLUS_in_czynnik2135 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_MINUS_in_czynnik2138 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_czynnik_bez_znaku_in_czynnik2143 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_zmienna_in_czynnik_bez_znaku2160 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LNAWIAS_in_czynnik_bez_znaku2168 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wyrazenie_in_czynnik_bez_znaku2171 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_PNAWIAS_in_czynnik_bez_znaku2173 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nazewnik_funkcji_in_czynnik_bez_znaku2182 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_stala_bez_znaku_in_czynnik_bez_znaku2190 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NOT_in_czynnik_bez_znaku2198 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_czynnik_bez_znaku_in_czynnik_bez_znaku2201 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_liczba_bez_znaku_in_stala_bez_znaku2218 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_napis_in_stala_bez_znaku2226 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NIL_in_stala_bez_znaku2234 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identyfikator_in_nazewnik_funkcji2251 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_LNAWIAS_in_nazewnik_funkcji2253 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_lista_parametrow_aktualnych_in_nazewnik_funkcji2255 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_PNAWIAS_in_nazewnik_funkcji2257 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parametr_aktualny_in_lista_parametrow_aktualnych2284 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_PRZECINEK_in_lista_parametrow_aktualnych2288 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_parametr_aktualny_in_lista_parametrow_aktualnych2290 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_identyfikator_in_instrukcja_procedury2323 = new BitSet(new long[]{0x0000000001000002L});
    public static final BitSet FOLLOW_LNAWIAS_in_instrukcja_procedury2327 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_lista_parametrow_aktualnych_in_instrukcja_procedury2329 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_PNAWIAS_in_instrukcja_procedury2331 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_wyrazenie_in_parametr_aktualny2362 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GOTO_in_instrukcja_skoku2379 = new BitSet(new long[]{0x0000000100000000L});
    public static final BitSet FOLLOW_etykieta_in_instrukcja_skoku2382 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_zlozona_in_instrukcja_strukturalna2414 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_warunkowa_in_instrukcja_strukturalna2422 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_iteracyjna_in_instrukcja_strukturalna2430 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_wiazaca_in_instrukcja_strukturalna2438 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BEGIN_in_instrukcja_zlozona2455 = new BitSet(new long[]{0x03A0002158000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_ciag_instrukcji_in_instrukcja_zlozona2460 = new BitSet(new long[]{0x0008000000000000L});
    public static final BitSet FOLLOW_END_in_instrukcja_zlozona2468 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_in_ciag_instrukcji2486 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_SREDNIK_in_ciag_instrukcji2490 = new BitSet(new long[]{0x03A0002158000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_instrukcja_in_ciag_instrukcji2492 = new BitSet(new long[]{0x0000000004000002L});
    public static final BitSet FOLLOW_instrukcja_jesli_in_instrukcja_warunkowa2521 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_wyboru_in_instrukcja_warunkowa2529 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_instrukcja_jesli2546 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wyrazenie_in_instrukcja_jesli2548 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_THEN_in_instrukcja_jesli2550 = new BitSet(new long[]{0x03A0002158000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_instrukcja_in_instrukcja_jesli2552 = new BitSet(new long[]{0x0000000000000002L,0x0000000000002000L});
    public static final BitSet FOLLOW_ELSE_in_instrukcja_jesli2566 = new BitSet(new long[]{0x03A0002158000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_instrukcja_in_instrukcja_jesli2568 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CASE_in_instrukcja_wyboru2604 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wyrazenie_in_instrukcja_wyboru2606 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_OF_in_instrukcja_wyboru2608 = new BitSet(new long[]{0x0000001F08000000L});
    public static final BitSet FOLLOW_element_listy_wyboru_in_instrukcja_wyboru2618 = new BitSet(new long[]{0x0008000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_instrukcja_wyboru2622 = new BitSet(new long[]{0x0000001F08000000L});
    public static final BitSet FOLLOW_element_listy_wyboru_in_instrukcja_wyboru2624 = new BitSet(new long[]{0x0008000004000000L});
    public static final BitSet FOLLOW_SREDNIK_in_instrukcja_wyboru2637 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_ELSE_in_instrukcja_wyboru2639 = new BitSet(new long[]{0x03A0002158000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_ciag_instrukcji_in_instrukcja_wyboru2641 = new BitSet(new long[]{0x0008000000000000L});
    public static final BitSet FOLLOW_END_in_instrukcja_wyboru2652 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_lista_stalych_wyboru_in_element_listy_wyboru2683 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_DWUKROPEK_in_element_listy_wyboru2685 = new BitSet(new long[]{0x03A0002158000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_instrukcja_in_element_listy_wyboru2687 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_dopoki_in_instrukcja_iteracyjna2714 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_powtarzaj_in_instrukcja_iteracyjna2722 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_instrukcja_dla_in_instrukcja_iteracyjna2730 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WHILE_in_instrukcja_dopoki2747 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wyrazenie_in_instrukcja_dopoki2749 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
    public static final BitSet FOLLOW_DO_in_instrukcja_dopoki2751 = new BitSet(new long[]{0x03A0002158000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_instrukcja_in_instrukcja_dopoki2753 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_REPEAT_in_instrukcja_powtarzaj2780 = new BitSet(new long[]{0x03A0002158000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_ciag_instrukcji_in_instrukcja_powtarzaj2782 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
    public static final BitSet FOLLOW_UNTIL_in_instrukcja_powtarzaj2784 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wyrazenie_in_instrukcja_powtarzaj2786 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_instrukcja_dla2813 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_identyfikator_in_instrukcja_dla2815 = new BitSet(new long[]{0x0400000000000000L});
    public static final BitSet FOLLOW_PRZYPISANIE_in_instrukcja_dla2817 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_sekwencja_for_in_instrukcja_dla2819 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
    public static final BitSet FOLLOW_DO_in_instrukcja_dla2821 = new BitSet(new long[]{0x03A0002158000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_instrukcja_in_instrukcja_dla2823 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_wartosc_poczatkowa_in_sekwencja_for2852 = new BitSet(new long[]{0x0000000000000000L,0x0000000000180000L});
    public static final BitSet FOLLOW_TO_in_sekwencja_for2855 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_DOWNTO_in_sekwencja_for2860 = new BitSet(new long[]{0x0000001F09000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_wartosc_koncowa_in_sekwencja_for2864 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_wyrazenie_in_wartosc_poczatkowa2881 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_wyrazenie_in_wartosc_koncowa2898 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WITH_in_instrukcja_wiazaca2915 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_lista_zmiennych_rekordowych_in_instrukcja_wiazaca2918 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
    public static final BitSet FOLLOW_DO_in_instrukcja_wiazaca2920 = new BitSet(new long[]{0x03A0002158000000L,0x0000000000254E00L});
    public static final BitSet FOLLOW_instrukcja_in_instrukcja_wiazaca2923 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_zmienna_in_lista_zmiennych_rekordowych2940 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_PRZECINEK_in_lista_zmiennych_rekordowych2944 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_zmienna_in_lista_zmiennych_rekordowych2947 = new BitSet(new long[]{0x0000000020000002L});

}